/*
 * Logica.java
 *
 * 
 * Created on September 1, 2007, 3:30 PM
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */
package wasolicitudesfiec.logicacontrol;
// <editor-fold defaultstate="collapsed" desc="import"> 

import espol.academico.DatosUsuarioResult;
import javax.xml.soap.SOAPElement;
import web.util.Constantes;
import entidad.*;
import entidad.apertura.Solicitudaperturapostgrado;
import entidad.apertura.Solicitudaperturatopico;
import entidad.ayudantias.Configuracion;
import entidad.ayudantias.Solicitudayudantia;

import entidad.ayudantias.Solicitudserayudante;
import entidad.ayudantias.TipoAyudantia;
import entidad.ayudantias.TipoAyudantia.TipoAyudantiaEnum;
import entidad.cambioCarrera.Solicitudcambiocarrera;
import entidad.convalidacionMateria.Solicitudconvalidacionmateria;
import espol.academico.CargadorXml;
import espol.academico.bean.NewDataSet;
import hero.client.test.SimpleCallbackHandler;
import hero.interfaces.*;
import hero.util.HeroException;
import java.rmi.RemoteException;
import java.sql.Connection;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.*;

import java.util.logging.Level;
import java.util.logging.Logger;
import javax.ejb.CreateException;
import javax.faces.context.ExternalContext;
import javax.naming.Context;
import javax.naming.NamingException;
import javax.security.auth.login.LoginContext;
import javax.security.auth.login.LoginException;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletResponse;
import wasolicitudesfiec.authentication.AuthenticationPhaseListener;
import wasolicitudesfiec.consultas.*;
import wasolicitudesfiec.consultas.apertura.ConsultasSolicitudaperturapostgrado;
import wasolicitudesfiec.consultas.apertura.ConsultasSolicitudaperturatopico;
import wasolicitudesfiec.consultas.ayudantias.*;
import wasolicitudesfiec.consultas.busqueda.BusquedaSolicitud;
import wasolicitudesfiec.consultas.cambioCarrera.ConsultasSolicitudcambiocarrera;
// </editor-fold>
import wasolicitudesfiec.consultas.convalidacionMateria.ConsultasSolicitudconvalidacionmateria;
import wasolicitudesfiec.general.MensajeException;
import wasolicitudesfiec.registros.Rg_Solicitud;
import web.util.SendMailEspol;

/**
 *
 * @author kabad
 */
public class Logica {

    ConexionDB conexionDB = new ConexionDB();
    private static String realPath;
    private ConsultasSolicitudayudantia consultasSolicitudayudantia = new ConsultasSolicitudayudantia();
    private ConsultasSolicitudserayudante consultasSolicitudserayudante = new ConsultasSolicitudserayudante();
    private ConsultasSolicitudcambiocarrera consultasSolicitudcambiocarrera = new ConsultasSolicitudcambiocarrera();
    private ConsultasSolicitudconvalidacionmateria consultasSolicitudconvalidacionmateria = new ConsultasSolicitudconvalidacionmateria();
    private ConsultasSolicitudaperturatopico consultasSolicitudaperturatopico = new ConsultasSolicitudaperturatopico();
    private ConsultasSolicitudaperturapostgrado consultasSolicitudaperturapostgrado = new ConsultasSolicitudaperturapostgrado();
    private ConsultasConfiguracion consultasConfiguracion = new ConsultasConfiguracion();
    private ConsultasMateria consultasMateria = new ConsultasMateria();
    private ConsultasProfesor consultasProfesor = new ConsultasProfesor();
    private ConsultasPersona consultasPersona = new ConsultasPersona();
    private ConsultasEstudiante consultasEstudiante = new ConsultasEstudiante();
    private ConsultasDatosacademicos consultasDatosacademicos = new ConsultasDatosacademicos();
    private ConsultasDatosfinancieros consultasDatosfinancieros = new ConsultasDatosfinancieros();
    private ConsultasDatosmateria consultasDatosmateria = new ConsultasDatosmateria();
    private ConsultasParametro consultasParametro = new ConsultasParametro();
    private ConsultasRol consultasRol = new ConsultasRol();
    private ConsultasPersonarol consultasPersonarol = new ConsultasPersonarol();
    private ConsultasProfesorcarrera consultasProfesorcarrera = new ConsultasProfesorcarrera();
    private ConsultasCategoria consultasCategoria = new ConsultasCategoria();
    private BusquedaSolicitud busquedaSolicitud = new BusquedaSolicitud();
    private LogAyudantia logAyudantia = null;
    private LogCambioCarrera logCambioCarrera = null;
    private LogConvalidacionMateria logConvalidacionMateria = null;
    private LogAperturaTopico logAperturaTopico = null;
    private LogAperturaPostgrado logAperturaPostgrado = null;
    private LogBusquedaSolicitud logBusquedaSolicitud = null;

    /** Creates a new instance of Logica */
    public Logica() {
    }

    public void cambiarDecano(Persona decano, Persona decanoAnterior) throws HeroException, RemoteException, SQLException {
        LogicaHistorial logicaHistorial = new LogicaHistorial();

        ProjectSession projectSession = getProjectSession();
        UserRegistration userRegistration = getUserRegistration();

        if (decano == null) {
            return; //No se admite que el decano sea null
        }
        try {
            //Tratamos de registrar al nuevo decano como usuario de Bonita
            userRegistration.userCreate(decano.getUsuario(), null, null);
        } catch (hero.util.HeroException ex) {
            //Probablemente ya existia el usuario
            Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, "No se pudo crear el usuario: " + decano.getUsuario() + " , probablemente ya existe");
        }

        Vector<Rg_Solicitud> listaInstancias = logicaHistorial.leerProcesosEnCursoPorRol(Constantes.RolBonita.Decano.getNombre());
        for (Rg_Solicitud rg_Solicitud : listaInstancias) {
            System.out.println("nombreInstancia: " + rg_Solicitud.getNombreinstanciaproceso());
            projectSession.initProject(rg_Solicitud.getNombreinstanciaproceso());

            //Remueve el rol Decano al decano anterior de la instancia de proceso
            try {
//                projectSession.unsetUser(decanoAnterior.getUsuario());
                if (decanoAnterior != null) {
                projectSession.unsetUserRole(decanoAnterior.getUsuario(), Constantes.RolBonita.Decano.getNombre());
                }
            } catch (hero.util.HeroException ex) {
                //El usuario no existe en el proyecto
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, "El usuario: " + decano.getUsuario() + " no se puede quitar porque no existe en la instancia" + rg_Solicitud.getNombreinstanciaproceso() + ", probablemente es un rol");
            }

            //Pone el nuevo decano en la instancia de proceso
            projectSession.addUser(decano.getUsuario());
            projectSession.setUserRole(decano.getUsuario(), Constantes.RolBonita.Decano.getNombre());
//            roles = projectSession.getUserRolesInProjectNames(decanoAnterior.getUsuario());
//            usuarios = projectSession.getUsers();
        }
    }

    public void cambiarSubDecano(Persona subdecano, Persona subdecanoAnterior) throws HeroException, RemoteException, SQLException {
        LogicaHistorial logicaHistorial = new LogicaHistorial();

        ProjectSession projectSession = getProjectSession();
        UserRegistration userRegistration = getUserRegistration();

        if (subdecano == null) {
            return; //No se admite que el decano sea null
        }
        try {
            //Tratamos de registrar al nuevo decano como usuario de Bonita
            userRegistration.userCreate(subdecano.getUsuario(), null, null);
        } catch (hero.util.HeroException ex) {
            //Probablemente ya existia el usuario
            Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, "No se pudo crear el usuario: " + subdecano.getUsuario() + " , probablemente ya existe");
        }

        Vector<Rg_Solicitud> listaInstancias = logicaHistorial.leerProcesosEnCursoPorRol(Constantes.RolBonita.Subdecano.getNombre());
        for (Rg_Solicitud rg_Solicitud : listaInstancias) {
//            System.out.println("nombreInstancia: " + rg_Solicitud.getNombreinstanciaproceso());
            projectSession.initProject(rg_Solicitud.getNombreinstanciaproceso());

            //Remueve el rol Decano al decano anterior de la instancia de proceso
            try {
//                projectSession.unsetUser(decanoAnterior.getUsuario());
                if (subdecanoAnterior != null) {
                    projectSession.unsetUserRole(subdecanoAnterior.getUsuario(), Constantes.RolBonita.Subdecano.getNombre());
                }
            } catch (hero.util.HeroException ex) {
                //El usuario no existe en el proyecto
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, "El usuario: " + subdecano.getUsuario() + " no se puede quitar porque no existe en la instancia" + rg_Solicitud.getNombreinstanciaproceso() + ", probablemente es un rol");
            }

            //Pone el nuevo decano en la instancia de proceso
            projectSession.addUser(subdecano.getUsuario());
            projectSession.setUserRole(subdecano.getUsuario(), Constantes.RolBonita.Subdecano.getNombre());
//            roles = projectSession.getUserRolesInProjectNames(decanoAnterior.getUsuario());
//            usuarios = projectSession.getUsers();
        }
    }

    public LogAperturaTopico getLogAperturaTopico() {
        if (logAperturaTopico == null) {
            logAperturaTopico = new LogAperturaTopico();
        }
        return logAperturaTopico;
    }

    public LogAperturaPostgrado getLogAperturaPostgrado() {
        if (logAperturaPostgrado == null) {
            logAperturaPostgrado = new LogAperturaPostgrado();
        }
        return logAperturaPostgrado;
    }

    public LogAyudantia getLogAyudantia() {
        if (logAyudantia == null) {
            logAyudantia = new LogAyudantia();
        }
        return logAyudantia;
    }

    public LogCambioCarrera getLogCambioCarrera() {
        if (logCambioCarrera == null) {
            logCambioCarrera = new LogCambioCarrera();
        }
        return logCambioCarrera;
    }

    public LogConvalidacionMateria getLogConvalidacionMateria() {
        if (logConvalidacionMateria == null) {
            logConvalidacionMateria = new LogConvalidacionMateria();
        }
        return logConvalidacionMateria;
    }

    public LogBusquedaSolicitud getLogBusquedaSolicitud() {
        if (logBusquedaSolicitud == null) {
            logBusquedaSolicitud = new LogBusquedaSolicitud();
        }
        return logBusquedaSolicitud;
    }

    // <editor-fold defaultstate="collapsed" desc="Metodos de autenticacion">
    public boolean autentica(String strUsuario, char[] strContrasena) {
        DatosUsuarioResult datosUsuario;
        SOAPElement datos;
        Persona persona;
        Vector<Rol> roles;
        Vector<Rol> nuevosRoles = new Vector<Rol>();
        Rol bonitaUserRol;
        Connection con;
        boolean existeBonitaUserRol = false;
        boolean esUsuarioEspol = false;
        Rol estudianteRol;
        Rol profesorRol;
        Rol secretariaRol;
        Constantes.Rol personarol = null;
        Rol administradorRol;

        try { // This code block invokes the DirectorioEspolSoap:datosUsuario operation on web service
            espol.academico.DirectorioEspol directorioEspol = new espol.academico.DirectorioEspol_Impl();
            espol.academico.DirectorioEspolSoap _directorioEspolSoap = directorioEspol.getDirectorioEspolSoap();
            datosUsuario = _directorioEspolSoap.datosUsuario(strUsuario, new String(strContrasena));

            if (datosUsuario != null) {
                datos = datosUsuario.get_any()[1];
                CargadorXml cargador = new CargadorXml();
                NewDataSet obj = cargador.getNewDataSet(datos.getFirstChild());

                if ("fiec".equalsIgnoreCase(obj.getDatosUsuario().getUnidad())) {
                    persona = leerPersonaPorUsuario(strUsuario);
                    if (persona == null) {
                        persona = new Persona();
                        roles = new Vector<Rol>();
                    } else {
                        roles = leerVariosRolPorIdPersona(persona.getIdPersona());
                    }
                    con = conexionDB.openConexion();
                    consultasRol.setConexion(con);
                    bonitaUserRol = consultasRol.leerRolPorNombre(Constantes.Rol.BonitaUser.getNombreEnBD(), -1);
                    estudianteRol = consultasRol.leerRolPorNombre(Constantes.Rol.Estudiante.getNombreEnBD(), -1);
                    profesorRol = consultasRol.leerRolPorNombre(Constantes.Rol.Profesor.getNombreEnBD(), -1);
                    secretariaRol = consultasRol.leerRolPorNombre(Constantes.Rol.Secretaria.getNombreEnBD(), -1);
                    administradorRol = consultasRol.leerRolPorNombre(Constantes.Rol.Administrador.getNombreEnBD(), -1);
if(bonitaUserRol==null){
throw new Exception("No se encontro el rol: " + Constantes.Rol.BonitaUser.getNombreEnBD());}
if(estudianteRol==null){
throw new Exception("No se encontro el rol: " + Constantes.Rol.Estudiante.getNombreEnBD());}
if(profesorRol==null){
throw new Exception("No se encontro el rol: " + Constantes.Rol.Profesor.getNombreEnBD());}
if(secretariaRol==null){
throw new Exception("No se encontro el rol: " + Constantes.Rol.Secretaria.getNombreEnBD());}
if(administradorRol==null){
throw new Exception("No se encontro el rol: " + Constantes.Rol.Administrador.getNombreEnBD());}
                    persona.setApellidos(obj.getDatosUsuario().getApellidos());
                    persona.setCedula(obj.getDatosUsuario().getCedula());
                    persona.setCorreo(obj.getDatosUsuario().getCorreo());
                    persona.setMatricula(obj.getDatosUsuario().getMatricula());
                    persona.setNombres(obj.getDatosUsuario().getNombres());
                    persona.setUsuario(strUsuario);
                    persona.setContraseña(new String(strContrasena));
                    nuevosRoles.add(bonitaUserRol);
                    if (Constantes.RolCSI.Estudiante.getNombre().equalsIgnoreCase(obj.getDatosUsuario().getRol())) {
                        personarol = Constantes.Rol.Estudiante;
                        nuevosRoles.add(estudianteRol);
                    } else if (Constantes.RolCSI.Docente.getNombre().equalsIgnoreCase(obj.getDatosUsuario().getRol())) {
                        personarol = Constantes.Rol.Profesor;
                        nuevosRoles.add(profesorRol);
                    } else if (Constantes.RolCSI.Administrativo.getNombre().equalsIgnoreCase(obj.getDatosUsuario().getRol())) {
                        personarol = Constantes.Rol.Secretaria;
                        nuevosRoles.add(secretariaRol);
                    }


                    for (Rol rol : roles) {
                        if (rol.getIdRol() == administradorRol.getIdRol()) {
                            nuevosRoles.add(administradorRol);
                        }
                    }
                    guardarPersona(persona, nuevosRoles);
                    esUsuarioEspol = true;
                }
            }
        } catch (javax.xml.rpc.ServiceException ex) {
            java.util.logging.Logger.getLogger(espol.academico.DirectorioEspol.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (java.rmi.RemoteException ex) {
            java.util.logging.Logger.getLogger(espol.academico.DirectorioEspol.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (Exception ex) {
            java.util.logging.Logger.getLogger(espol.academico.DirectorioEspol.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        }

        if (esUsuarioEspol) {
            System.setProperty(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.rmi.registry.RegistryContextFactory");//Linea agregada
            SimpleCallbackHandler handler = new SimpleCallbackHandler(strUsuario, strContrasena);
            LoginContext lc;
            try {
//            Hashtable environment = new Hashtable();
//            environment.put("java.naming.provider.url","rmi://localhost:1099/");
                lc = new LoginContext("TestClient", handler);
                lc.login();
                ProjectSessionHome prjHome = (ProjectSessionHome) ProjectSessionUtil.getHome();
                UserRegistrationHome userRHome = (UserRegistrationHome) UserRegistrationUtil.getHome();
                UserSessionHome usrHome = (UserSessionHome) UserSessionUtil.getHome();
                ProjectSession prjSession = prjHome.create();
                UserRegistration usrReg = userRHome.create();
                UserSession usrSession = usrHome.create();
//            usrReg.userCreate("juanitoLimaña", "password", "correo@espol.edu.ec");
                return true;
//        } catch (HeroException ex) {
//            Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            } catch (LoginException ex) {
                ex.printStackTrace();
            } catch (RemoteException ex) {
                ex.printStackTrace();
            } catch (CreateException ex) {
                ex.printStackTrace();
            } catch (NamingException ex) {
                ex.printStackTrace();
            }
        }
        return false;

    }

    public boolean autentica(String strUsuario, char[] strContrasena, ExternalContext externalContext) {
        ProjectSessionHome prjHome;
        // User Adminauthentication
        if (strUsuario == null) {
            strUsuario = "lbeltran";
        }
        if (strContrasena == null) {
            strContrasena = new char[3];
            strContrasena[0] = '1';
            strContrasena[1] = '2';
            strContrasena[2] = '3';
        }
        boolean seAutentico = autentica(strUsuario, strContrasena);

        if (seAutentico) {
            Usuario usuario = new Usuario();
            usuario.setPassword(strContrasena);
            usuario.setUsuario(strUsuario);

            externalContext.getSessionMap().put(AuthenticationPhaseListener.USER_SESSION_KEY, usuario);
        }

        return seAutentico;
    }

    public boolean autenticaComodin() {
        char[] passComodin = new char[7];
        passComodin[0] = 'c';
        passComodin[1] = 'o';
        passComodin[2] = 'm';
        passComodin[3] = 'o';
        passComodin[4] = 'd';
        passComodin[5] = 'i';
        passComodin[6] = 'n';
        return autentica("comodin", passComodin);
    }
    // </editor-fold>
    // <editor-fold defaultstate="collapsed" desc="Metodos de administracion de procesos, actividades y objetos de bonita">

    public UserRegistration getUserRegistration() {
        UserRegistrationHome userRHome;
        try {
            userRHome = (UserRegistrationHome) UserRegistrationUtil.getHome();
            UserRegistration urSession = userRHome.create();
            return urSession;
        } catch (RemoteException ex) {
            ex.printStackTrace();
        } catch (CreateException ex) {
            ex.printStackTrace();
        } catch (NamingException ex) {
            ex.printStackTrace();
        }
        return null;
    }

    public ProjectSession getProjectSession() {
        ProjectSessionHome prjHome;

        try {
            prjHome = (ProjectSessionHome) ProjectSessionUtil.getHome();
            ProjectSession prjSession = prjHome.create();
            return prjSession;
        } catch (RemoteException ex) {
            ex.printStackTrace();
        } catch (CreateException ex) {
            ex.printStackTrace();
        } catch (NamingException ex) {
            ex.printStackTrace();
        }
        return null;
    }

    public UserSession getUserSession() {
        UserSession usrSession;
        UserSessionHome usrHome;

        try {
            usrHome = UserSessionUtil.getHome();
            usrSession = usrHome.create();

            return usrSession;
        } catch (RemoteException ex) {
            ex.printStackTrace();
        } catch (CreateException ex) {
            ex.printStackTrace();
        } catch (NamingException ex) {
            ex.printStackTrace();
        }
        return null;
    }

    public static void setRealPath(String realPath1) {
        realPath = realPath1;
    }

    public static String getRealPath() {
        return realPath;
    }

    public static String getRealPath_XML() {
        return realPath + "xml\\";
    }

    public Vector<BnProjectLightValue> leerProcesosAIniciarDelUsuario() {
        Collection listaBnProjectLightValue;
        UserSession usrSession;
        UserSessionHome usrHome;

        Vector<BnProjectLightValue> listaProcesos = new Vector<BnProjectLightValue>();
        try {
            usrHome = UserSessionUtil.getHome();
            usrSession = usrHome.create();
            listaBnProjectLightValue = usrSession.getModels();
            for (Object elem : listaBnProjectLightValue) {
                BnProjectLightValue pr = (BnProjectLightValue) elem;
                listaProcesos.add(pr);
            }
        } catch (RemoteException ex) {
            ex.printStackTrace();
        } catch (HeroException ex) {
            ex.printStackTrace();
        } catch (NamingException ex) {
            ex.printStackTrace();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return listaProcesos;
    }

    public String leerNombreDeLaPrimeraActividad(String nombreModelo, String version) {
        BnEdgeValue edge;
        BnNodeLightValue actividad;
        ProjectSessionHome prjHome;
        Collection listaModelos;
        UserSession usrSession;
        UserSessionHome usrHome;
        HashMap<String, BnNodeLightValue> actividades = new HashMap<String, BnNodeLightValue>();
        try {
            usrHome = UserSessionUtil.getHome();
            usrSession = usrHome.create();

            prjHome = (ProjectSessionHome) ProjectSessionUtil.getHome();
            ProjectSession prjSession = prjHome.create();

            if (prjSession.existingProject(nombreModelo, version)) {
//                System.out.println("si existe el modelo: "+nombreModelo);
                prjSession.initModelWithVersion(nombreModelo, version);
//                System.out.println("prjSession.getName(): "+prjSession.getName());


                for (Object elem : prjSession.getNodesNames()) {
//                    System.out.println("Nodo: "+elem);
                    actividad = prjSession.getNodeLightValue((String) elem);
                    actividades.put((String) elem, actividad);

                }
                for (Object elem : prjSession.getEdgesNames()) {
                    edge = prjSession.getEdgeValue((String) elem);
//                    System.out.println("Edge: "+elem+" salida: "+edge.getOutBnNode().getName()+" actividad de llegada:"+edge.getInBnNode().getName());
                    actividades.remove(edge.getOutBnNode().getName());
                }
                if (actividades.size() > 0) {
//                    System.out.println("Si quedo una actividad:xx "+((BnNodeLightValue)actividades.values().toArray()[0]).getName());
                    return ((BnNodeLightValue) actividades.values().toArray()[0]).getName();
                }
            }
        } catch (RemoteException ex) {
            ex.printStackTrace();
        } catch (HeroException ex) {
            ex.printStackTrace();
        } catch (NamingException ex) {
            ex.printStackTrace();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return null;
    }

    public ArrayList<String> leerProcesosEnCurso(UserSession usrSession) {
        ArrayList<String> instancias = null;
        try {
            instancias = (ArrayList<String>) usrSession.getProjectListNames();

        } catch (HeroException ex) {
            ex.printStackTrace();
            Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
        } catch (RemoteException ex) {
            ex.printStackTrace();
            Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
        }
        return instancias;
    }

    public ArrayList<BnNodeValue> leerActividadesPendientes(String nombreModelo, String versionModelo, UserSession usrSession, ProjectSession prjSession) throws HeroException, RemoteException {
        BnNodeValue actividadTemp;
        Collection actividadesPorHacer;
        Collection instancias;
        ArrayList<BnNodeValue> listaActividadesPendientes = new ArrayList<BnNodeValue>();

        instancias = usrSession.getProjectInstancesNames(nombreModelo, versionModelo);
        String nombreInstancia;
        for (Object elem : instancias) {
            nombreInstancia = (String) elem;
            System.out.println("nombreInstancia: " + nombreInstancia);
            actividadesPorHacer = usrSession.getToDoList(nombreInstancia);
            prjSession.initProject(nombreInstancia);
            for (Object elem2 : actividadesPorHacer) {
                System.out.println(elem2);
                actividadTemp = prjSession.getNodeValue((String) elem2);
                listaActividadesPendientes.add(actividadTemp);
            }
        }

        return listaActividadesPendientes;
    }

    public ArrayList<HashMap<String, String>> leerModelosDeActividadesPendientes() {
        String nombreModelo;
        ArrayList<HashMap<String, String>> listaModelosPendientes = new ArrayList<HashMap<String, String>>();
        HashMap mapaModelosPendientes = new HashMap();
        Collection listaPorHacer;
        Collection instancias;
        ProjectSessionHome prjHome;
        UserSession usrSession;
        UserSessionHome usrHome;
        Collection lstModels;
        BnProjectLightValue instancia;
        HashMap<String, String> mapaModelo;
        try {
            usrHome = UserSessionUtil.getHome();
            usrSession = usrHome.create();

            prjHome = (ProjectSessionHome) ProjectSessionUtil.getHome();
            ProjectSession prjSession = prjHome.create();

            lstModels = usrSession.getModelList();
            for (Object object : lstModels) {
                System.out.println("Modelo: " + object);
            }
            instancias = usrSession.getProjectList();

            for (Object elem : instancias) {
                instancia = (BnProjectLightValue) elem;
                prjSession.initProject(instancia.getName());
//                    System.out.println("parent: "+prjSession.getParent()+" getProjectNameOfInstance: "+prjSession.getProjectNameOfInstance((String) elem));
                listaPorHacer = usrSession.getToDoList(instancia.getName());
                if (listaPorHacer != null && listaPorHacer.size() > 0) {
                    nombreModelo = prjSession.getProjectNameOfInstance(instancia.getName());
//                    listaModelosPendientes.add(prjSession.getProjectNameOfInstance((String) elem));
                    if (mapaModelosPendientes.get(nombreModelo) == null) {
                        mapaModelosPendientes.put(nombreModelo, nombreModelo);
                        mapaModelo = new HashMap<String, String>();
                        mapaModelo.put("nombreModelo", nombreModelo);
                        mapaModelo.put("version", instancia.getVersion());
                        listaModelosPendientes.add(mapaModelo);
                    }
                }
            }
        } catch (RemoteException ex) {
            ex.printStackTrace();
        } catch (CreateException ex) {
            ex.printStackTrace();
        } catch (NamingException ex) {
            ex.printStackTrace();
        } catch (HeroException ex) {
            ex.printStackTrace();
        }
        return listaModelosPendientes;
    }

    public String getProjectNameOfInstance(String instanceNombre) {
        String modelo = null;
        ProjectSessionHome prjHome;
        try {
            prjHome = (ProjectSessionHome) ProjectSessionUtil.getHome();
            ProjectSession prjSession = prjHome.create();
            modelo = prjSession.getProjectNameOfInstance(instanceNombre);

        } catch (RemoteException ex) {
            ex.printStackTrace();
        } catch (CreateException ex) {
            ex.printStackTrace();
        } catch (NamingException ex) {
            ex.printStackTrace();
        } catch (HeroException ex) {
            ex.printStackTrace();
        }
        return modelo;
    }

    public String leerVersionModelo(String instanceNombre) {

        ProjectSessionHome prjHome;
        String modelo = null;
        String version = null;
        try {
            prjHome = (ProjectSessionHome) ProjectSessionUtil.getHome();
            ProjectSession prjSession = prjHome.create();
            modelo = prjSession.getProjectNameOfInstance(instanceNombre);
            if (modelo.equals(Constantes.Modelo.modelo_SolicitarAyudantes)) {
                version = Constantes.Modelo.version_SolicitarAyudantes;
            } else if (modelo.equals(Constantes.Modelo.modelo_SolicitarSerAyudante)) {
                version = Constantes.Modelo.version_SolicitarSerAyudante;
            } else if (modelo.equals(Constantes.Modelo.modelo_SolicitarCambioCarrera)) {
                version = Constantes.Modelo.version_SolicitarCambioCarrera;
            }
        } catch (NamingException ex) {
            Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
        } catch (CreateException ex) {
            Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
        } catch (HeroException ex) {
            Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
        } catch (RemoteException ex) {
            Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
        }
        return version;
    }

    // </editor-fold>
    // <editor-fold defaultstate="collapsed" desc="Metodos de consultas de ayudantias y materias">
    //Convierte una materia a una logAyudantia para poder ser agregada luego en la lista de ayudantias
    public Parametro materiaToAyudantia(Materia materia) {
        Parametro tempAyudantia;
        tempAyudantia = new Parametro();
        tempAyudantia.setIdParametro(materia.getIdMateria());
        tempAyudantia.setNombre(materia.getNombre());
        tempAyudantia.setDescripcion(materia.getCodigo());
        return tempAyudantia;
    }
    // Retorna un vetor con las ayudantias dependiendo del tipo
    // tipo 0 -> Ayudantias academicas
    // tipo 1 -> Ayudantias Actividades Varias

    public Vector<Parametro> leerAyudantias(TipoAyudantiaEnum tipoAyudantia) throws SQLException {
        Vector<Materia> listaMaterias;
        Vector<Parametro> listaAyudantias;
        if (tipoAyudantia == TipoAyudantiaEnum.ACADEMICA) {//AyudantÃƒÂ­as AcadÃƒÂ©micas

            Parametro tempAyudantia;
            listaAyudantias = new Vector<Parametro>();
            listaMaterias = leerTodasLasMaterias();
            for (Materia elemMateria : listaMaterias) {
                tempAyudantia = materiaToAyudantia(elemMateria); //convierte una materia en logAyudantia

                listaAyudantias.add(tempAyudantia);
            }
        } else {//Ayudantías Varias

            listaAyudantias = leerTodasLasAyudantiasVarias();
        }
        return listaAyudantias;
    }

    public void guardarMateria(Materia materia) throws SQLException {
        Connection con = null;
        try {
            con = conexionDB.openConexion();
            consultasMateria.setConexion(con);
            con.setAutoCommit(false);
            if (materia.getIdMateria() > 0) {
                consultasMateria.HLmodificarMateria(materia);
            } else {
                consultasMateria.HLnuevoMateria(materia);
            }
            con.commit();
        } finally {
            if (con != null && !con.isClosed()) {
                con.close();
            }
        }
    }

    public void eliminarMateria(int idMateria) throws SQLException {
        Connection con = null;
        try {
            con = conexionDB.openConexion();
            consultasMateria.setConexion(con);
            con.setAutoCommit(false);
            consultasMateria.eliminarMateria(idMateria);
            con.commit();
        } finally {
            if (con != null && !con.isClosed()) {
                con.close();
            }
        }
    }

    public Materia leerMateria(int idMateria) throws SQLException {
        Connection con = null;
        Materia materia;
        try {
            con = conexionDB.openConexion();
            consultasMateria.setConexion(con);
            materia = consultasMateria.leerMateria(idMateria);
        } finally {
            if (con != null) {
                con.close();
            }
        }
        return materia;
    }

    public Vector<Materia> leerTodasLasMaterias() throws SQLException {
        Vector<Materia> listaMaterias = new Vector<Materia>();
        Connection con = null;
        try {
            con = conexionDB.openConexion();
            consultasMateria.setConexion(con);
            listaMaterias = consultasMateria.leerVariosMateria();
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return listaMaterias;
    }

    public Vector<Parametro> leerTodasLasAyudantiasVarias() throws SQLException {
        Vector<Parametro> listaAyudantias = new Vector<Parametro>();
        Connection con = null;
        try {
            con = conexionDB.openConexion();
            consultasParametro.setConexion(con);
            listaAyudantias = consultasParametro.leerVariosParametroPorNombreCategoria(Constantes.Categoria.ayudantia_varia.getNombreEnBD());
        } finally {
            if (con != null) {
                con.close();
            }
        }
        return listaAyudantias;
    }

    public TipoAyudantia leerTipoAyudantia(Solicitudayudantia solicitud) {
        TipoAyudantia tipoAyudantia = new TipoAyudantia();
        if (solicitud.getFkIdMateria() != 0) {
            tipoAyudantia.setTipo(TipoAyudantia.TipoAyudantiaEnum.ACADEMICA);
            tipoAyudantia.setNombre("AcadÃƒÆ’Ã‚Â©mica");
        } else {
            tipoAyudantia.setTipo(TipoAyudantia.TipoAyudantiaEnum.ACTIVIDADES_VARIAS);
            tipoAyudantia.setNombre("Actividades Varias");
        }
        return tipoAyudantia;
    }
    // </editor-fold>
    // <editor-fold defaultstate="collapsed" desc="Metodos de consultas Configuracion ">

    public Configuracion leerConfiguracionPorId(int idConfiguracion) throws SQLException, MensajeException {
        Configuracion configuracion;
        Connection con = null;
        try {
            con = conexionDB.openConexion();
            consultasConfiguracion.setConexion(con);
            configuracion = consultasConfiguracion.leerConfiguracion(idConfiguracion);
            if (configuracion == null) {
                throw new MensajeException("La configuración que buscar no existe");
            }
        } finally {
            if (con != null) {
                con.close();
            }
        }
        return configuracion;
    }

    public Configuracion leerConfiguracionPorNombre(String nombre) throws SQLException {
        Configuracion configuracion;
        Connection con = null;
        try {
            con = conexionDB.openConexion();
            consultasConfiguracion.setConexion(con);
            configuracion = consultasConfiguracion.leerConfiguracionPorNombre(nombre);
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return configuracion;
    }

    public Vector<Configuracion> leerTodasConfiguraciones() throws SQLException {
        Connection con = null;
        Vector<Configuracion> listaConfiguracion = new Vector<Configuracion>();
        try {
            con = conexionDB.openConexion();
            consultasConfiguracion.setConexion(con);
            listaConfiguracion = consultasConfiguracion.leerVariosConfiguracion();
        } finally {
            if (con != null) {
                con.close();
            }
        }
        return listaConfiguracion;

    }

    public void guardarConfiguracion(Configuracion configuracion) throws SQLException {
        Connection con = null;
        try {
            con = conexionDB.openConexion();
            con.setAutoCommit(false);
            consultasConfiguracion.setConexion(con);
            if (configuracion.getIdConfiguracion() > 0) {
                consultasConfiguracion.HLmodificarConfiguracion(configuracion);
            } else {
                consultasConfiguracion.HLnuevoConfiguracion(configuracion);
            }
            con.commit();
        } finally {
            if (con != null && !con.isClosed()) {
                con.close();
            }
        }
    }
    // </editor-fold>
    // <editor-fold defaultstate="collapsed" desc="Metodos de consultas Carrera, Especializacion, ayudantiaVaria (tabla parametro) ">

    public void nuevoParametro(Parametro parametro) throws SQLException, Exception {
        Connection con = null;
        Parametro nuevoParametro = null;
        try {
            con = conexionDB.openConexion();
            con.setAutoCommit(false);
            consultasParametro.setConexion(con);
            nuevoParametro = consultasParametro.HLnuevoParametro(parametro);
            Vector<Parametro> listaParametro = parametro.getListaParametro();
            if ((listaParametro != null) && (nuevoParametro != null)) {
                for (Parametro item : listaParametro) {
                    consultasParametro.nuevoParametro(item.getFkIdCategoria(), nuevoParametro.getIdParametro(), item.getNombre(), item.isActivo(), item.getDescripcion());
                }
            }
            con.commit();
        } catch (Exception ex) {
            if (con != null) {
                con.rollback();
            }
            throw ex;
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }

    public void modificarParametro(Parametro parametro) throws SQLException, Exception {
        Connection con = null;
        try {
            con = conexionDB.openConexion();
            con.setAutoCommit(false);
            consultasParametro.setConexion(con);
            consultasParametro.HLmodificarParametro(parametro);
            Vector<Parametro> listaParametro = parametro.getListaParametro();
            if ((listaParametro != null) && (parametro != null)) {

                Vector<Parametro> listaParametroExistentes = consultasParametro.leerVariosParametroPorIdfkParent(parametro.getIdParametro());
                for (Parametro item : listaParametro) {
                    boolean existe = false;
                    for (Parametro parametroExistente : listaParametroExistentes) {
                        existe = false;
                        if (parametroExistente.getNombre().equals(item.getNombre())) {
                            existe = true;
                            break;
                        }
                    }
                    if (!existe) {
                        consultasParametro.nuevoParametro(item.getFkIdCategoria(), parametro.getIdParametro(), item.getNombre(), item.isActivo(), item.getDescripcion());
                    }
                }
            }
            con.commit();
        } catch (Exception ex) {
            if (con != null) {
                con.rollback();
            }
            throw ex;
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }

    public Vector<Parametro> leerVariosParametroPorIdCategoria(int idCategoria) throws SQLException {
        Vector<Parametro> listaCarreras = new Vector<Parametro>();
        Connection con = null;
        try {
            con = conexionDB.openConexion();
            consultasParametro.setConexion(con);
            listaCarreras = consultasParametro.leerVariosParametroPorIdCategoria(idCategoria);
            for (Parametro parametro : listaCarreras) {
                Vector<Parametro> especializaciones = consultasParametro.leerVariosParametroPorIdfkParent(parametro.getIdParametro());
                parametro.setListaParametro(especializaciones);
            }
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return listaCarreras;
    }

    public Vector<Parametro> leerVariosParametroPorIdfkParent(int idParametro) throws SQLException {
        Vector<Parametro> listaEspecializacion = new Vector<Parametro>();
        Connection con = null;
        try {
            con = conexionDB.openConexion();
            consultasParametro.setConexion(con);

            listaEspecializacion = consultasParametro.leerVariosParametroPorIdfkParent(idParametro);
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return listaEspecializacion;
    }

    public Parametro leerParametro(int idParametro) throws SQLException {
        Parametro parametro;
        Vector<Parametro> listaParametro = new Vector<Parametro>();

        Connection con = null;
        Categoria categoria;
        try {
            con = conexionDB.openConexion();
            consultasParametro.setConexion(con);
            consultasCategoria.setConexion(con);
            parametro = consultasParametro.leerParametro(idParametro);
            if (parametro != null) {
                listaParametro = consultasParametro.leerVariosParametroPorIdfkParent(parametro.getIdParametro());
                parametro.setListaParametro(listaParametro);
                categoria = consultasCategoria.leerCategoria(parametro.getFkIdCategoria());
                parametro.setCategoria(categoria);
            }

        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return parametro;
    }

    public Parametro leerAyudantiaVaria(int idAyudantiaVaria) throws SQLException, MensajeException {
        Parametro parametro;
        Vector<Parametro> listaParametro = new Vector<Parametro>();

        Connection con = null;
        Categoria categoria;
        try {
            con = conexionDB.openConexion();
            consultasParametro.setConexion(con);
            consultasCategoria.setConexion(con);
            parametro = consultasParametro.leerParametro(idAyudantiaVaria);
            if (parametro == null) {
                throw new MensajeException("La ayudantia varia que busca no existe");
            }
            listaParametro = consultasParametro.leerVariosParametroPorIdfkParent(parametro.getIdParametro());
            parametro.setListaParametro(listaParametro);
            categoria = consultasCategoria.leerCategoria(parametro.getFkIdCategoria());
            if (!categoria.getNombre().equals(Constantes.Categoria.ayudantia_varia.getNombreEnBD())) {
                throw new MensajeException("La ayudantia varia que busca no existe");
            }
            parametro.setCategoria(categoria);

        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return parametro;
    }

    public void guardarAyudantiaVaria(Parametro ayudantia) throws SQLException, MensajeException {
        Connection con = null;
        Parametro parametro;
        try {
            con = conexionDB.openConexion();
            con.setAutoCommit(false);
            consultasParametro.setConexion(con);
            consultasCategoria.setConexion(con);
            Categoria categoria = consultasCategoria.leerCategoria(Constantes.Categoria.ayudantia_varia.getNombreEnBD());
            if (ayudantia.getIdParametro() > 0 && ayudantia.getFkIdCategoria() != categoria.getIdCategoria()) {
                throw new MensajeException("El objeto que intenta guardar no es una ayudantía varia");
            }
            if (ayudantia.getIdParametro() > 0) {
                consultasParametro.HLmodificarParametro(ayudantia);
            } else {
                ayudantia.setFkIdCategoria(categoria.getIdCategoria());
                parametro = consultasParametro.HLnuevoParametro(ayudantia);
                ayudantia.setIdParametro(parametro.getIdParametro());
            }
            con.commit();
        } finally {
            if (con != null && !con.isClosed()) {
                con.close();
            }
        }

    }

    public void eliminarAyudantiaVaria(int idAyudantiaVaria) throws SQLException {
        Connection con = null;
        try {
            con = conexionDB.openConexion();
            con.setAutoCommit(false);
            consultasParametro.setConexion(con);
            consultasParametro.eliminarParametro(idAyudantiaVaria);
            con.commit();
        } finally {
            if (con != null && !con.isClosed()) {
                con.close();
            }
        }

    }

    public Carrera leerCarrera(int idCarrera) throws SQLException, MensajeException {
        Carrera carrera;
        Parametro parametro;
        Vector<Parametro> listaParametro = new Vector<Parametro>();
        Vector<Especializacion> listaEspecializacion = new Vector<Especializacion>();

        Connection con = null;
        Profesor profesor;
        Categoria categoria;
        Especializacion especializacion;
        try {
            con = conexionDB.openConexion();
            consultasParametro.setConexion(con);
            consultasCategoria.setConexion(con);
            parametro = consultasParametro.leerParametro(idCarrera);
            if (parametro == null) {
                throw new MensajeException("La carrera que busca no existe");
            }
            listaParametro = consultasParametro.leerVariosParametroPorIdfkParent(parametro.getIdParametro());
            for (Parametro especializacionPara : listaParametro) {
                especializacion = new Especializacion(especializacionPara);
                categoria = consultasCategoria.leerCategoria(especializacionPara.getFkIdCategoria());
                especializacion.setCategoria(categoria);
                profesor = leerProfesorPorCarrera(especializacion.getIdParametro());
                if (profesor != null) {
                    especializacion.setCoordinador(profesor);
                    especializacion.setFkCoordinador(profesor.getIdProfesor());
                }
                listaEspecializacion.add(especializacion);
            }
            categoria = consultasCategoria.leerCategoria(parametro.getFkIdCategoria());
            parametro.setCategoria(categoria);
            if (!categoria.getNombre().equals(Constantes.Categoria.carrera.getNombreEnBD())) {
                throw new MensajeException("La carrera que busca no existe");
            }

            profesor = leerProfesorPorCarrera(idCarrera);
            carrera = new Carrera(parametro);
            if (profesor != null) {
                carrera.setCoordinador(profesor);
                carrera.setFkCoordinador(profesor.getIdProfesor());
            }
            carrera.setListaEspecializacion(listaEspecializacion);
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return carrera;
    }

    public void guardarCarrera(Carrera carrera) throws SQLException, MensajeException {
        Connection con = null;
        Parametro parametro;
        Categoria categoria_especializacion;
        Categoria categoria_carrera;
        try {
            con = conexionDB.openConexion();
            con.setAutoCommit(false);
            consultasParametro.setConexion(con);
            consultasProfesorcarrera.setConexion(con);
            consultasCategoria.setConexion(con);
            if (carrera.getIdParametro() > 0) {
                categoria_carrera = consultasCategoria.leerCategoria(carrera.getFkIdCategoria());
                if (!categoria_carrera.getNombre().equals(Constantes.Categoria.carrera.getNombreEnBD())) {
                    throw new MensajeException("El objeto que intenta guardar no es una carrera");
                }
                consultasParametro.HLmodificarParametro(carrera);
            } else {
                categoria_carrera = consultasCategoria.leerCategoria(Constantes.Categoria.carrera.getNombreEnBD());
                carrera.setFkIdCategoria(categoria_carrera.getIdCategoria());
                parametro = consultasParametro.HLnuevoParametro(carrera);
                carrera.setIdParametro(parametro.getIdParametro());
            }
            consultasProfesorcarrera.eliminarProfesorcarreraPorIdCarrera(carrera.getIdParametro());
            if (carrera.getFkCoordinador() > 0) {
                consultasProfesorcarrera.nuevoProfesorcarrera(carrera.getIdParametro(), carrera.getFkCoordinador());
            }

            categoria_especializacion = consultasCategoria.leerCategoria(Constantes.Categoria.especializacion.getNombreEnBD());
            for (Especializacion especializacion : carrera.getListaEspecializacion()) {
                especializacion.setFkIdParent(carrera.getIdParametro());
                especializacion.setFkIdCategoria(categoria_especializacion.getIdCategoria());
                if (especializacion.getIdParametro() > 0 && especializacion.isEliminar()) {
                    consultasParametro.eliminarParametro(especializacion.getIdParametro());
                } else if (especializacion.getIdParametro() > 0) {
                    consultasParametro.HLmodificarParametro(especializacion);
                } else if (!especializacion.isEliminar()) {
                    parametro = consultasParametro.HLnuevoParametro(especializacion);
                    especializacion.setIdParametro(parametro.getIdParametro());
                }
                consultasProfesorcarrera.eliminarProfesorcarreraPorIdCarrera(especializacion.getIdParametro());
                if (especializacion.getFkCoordinador() > 0) {
                    consultasProfesorcarrera.nuevoProfesorcarrera(especializacion.getIdParametro(), especializacion.getFkCoordinador());
                }
            }
            con.commit();
        } finally {
            if (con != null && !con.isClosed()) {
                con.close();
            }
        }
    }

    public Vector<Parametro> leerTodasLasCarreras() throws SQLException {
        Vector<Parametro> listaCarreras = new Vector<Parametro>();
        Connection con = null;
        Vector<Parametro> listaEspecializacion;
        try {
            con = conexionDB.openConexion();
            consultasParametro.setConexion(con);
            listaCarreras = consultasParametro.leerVariosParametroPorNombreCategoria(Constantes.Categoria.carrera.getNombreEnBD());
            for (Parametro carrera : listaCarreras) {
                listaEspecializacion = consultasParametro.leerVariosParametroPorIdfkParent(carrera.getIdParametro());
                carrera.setListaParametro(listaEspecializacion);
            }

        } finally {
            if (con != null) {
                con.close();
            }
        }
        return listaCarreras;
    }
    // </editor-fold>
    // <editor-fold defaultstate="collapsed" desc="Metodos de consultas Persona, Rol">

    public void eliminarPersonaRol(Personarol var_personarol) throws SQLException, Exception {
        Connection con = null;
        try {
            con = conexionDB.openConexion();
            con.setAutoCommit(false);
            consultasPersonarol.setConexion(con);
            consultasPersonarol.HLeliminarPersonarol(var_personarol);
            con.commit();
        } catch (Exception ex) {
            if (con != null) {
                con.rollback();
            }
            throw ex;
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }

    public Personarol nuevoPersonaRol(Personarol var_personarol) throws SQLException, Exception {
        Connection con = null;
        Personarol personarol = null;
        try {
            con = conexionDB.openConexion();
            con.setAutoCommit(false);
            consultasPersonarol.setConexion(con);
            personarol = consultasPersonarol.HLnuevoPersonarol(var_personarol);
            con.commit();
        } catch (Exception ex) {
            if (con != null) {
                con.rollback();
            }
            throw ex;
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return personarol;
    }

    public void nuevoRolMiembros(Rol rol, Vector<Persona> listaMiembros) throws SQLException, Exception {
        Connection con = null;
        Rol nuevorol = null;
        try {
            con = conexionDB.openConexion();
            con.setAutoCommit(false);
            consultasPersonarol.setConexion(con);
            consultasRol.setConexion(con);
            nuevorol = consultasRol.HLnuevoRol(rol);
            for (Persona persona : listaMiembros) {
                int idRol = nuevorol.getIdRol();
                int idPersona = persona.getIdPersona();
                consultasPersonarol.nuevoPersonarol(idPersona, idRol);
            }

            con.commit();
        } catch (Exception ex) {
            if (con != null) {
                con.rollback();
            }
            throw ex;
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }

    public void modificarRolMiembros(Rol rol, Vector<Persona> listaMiembros) throws SQLException, Exception {
        Connection con = null;
        try {
            con = conexionDB.openConexion();
            con.setAutoCommit(false);
            consultasPersonarol.setConexion(con);
            consultasRol.setConexion(con);
            consultasRol.HLmodificarRol(rol);
            for (Persona persona : listaMiembros) {
                int idRol = rol.getIdRol();
                int idPersona = persona.getIdPersona();
                Personarol personarol = consultasPersonarol.leerPersonarol(idPersona, idRol);
                if (personarol == null) {
                    consultasPersonarol.nuevoPersonarol(idPersona, idRol);
                }
            }

            con.commit();
        } catch (Exception ex) {
            if (con != null) {
                con.rollback();
            }
            throw ex;
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }

    public void eliminarRolMiembros(int idRol, Vector<Persona> listaMiembros) throws SQLException, Exception {
        Connection con = null;
        try {
            con = conexionDB.openConexion();
            con.setAutoCommit(false);
            consultasPersonarol.setConexion(con);
            consultasRol.setConexion(con);
            consultasRol.eliminarRol(idRol);
            for (Persona persona : listaMiembros) {
                int idPersona = persona.getIdPersona();
                Personarol personarol = consultasPersonarol.leerPersonarol(idPersona, idRol);
                if (personarol == null) {
                    consultasPersonarol.nuevoPersonarol(idPersona, idRol);
                }
            }

            con.commit();
        } catch (Exception ex) {
            if (con != null) {
                con.rollback();
            }
            throw ex;
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }

    public Vector<Persona> leerPersonaPorRol(String nombreRol) {
        Connection con = null;
        Vector<Persona> personas = new Vector<Persona>();
        Vector<Personarol> personasRol = new Vector<Personarol>();
        Rol rol;
        try {
            con = conexionDB.openConexion();
            consultasPersona.setConexion(con);
            consultasPersonarol.setConexion(con);
            consultasRol.setConexion(con);
            rol = consultasRol.leerRolPorNombre(nombreRol, -1);
            personasRol = consultasPersonarol.leerVariosPersonarolPorIdRol(rol.getIdRol());
            for (Personarol personarol : personasRol) {
                personas.add(consultasPersona.leerPersona(personarol.getFkIdPersona()));
            }
        } catch (SQLException ex) {
            Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            try {
                con.close();
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return personas;
    }
    public Vector<Persona> leerVariosPersonasPoridRol(int idRol) throws SQLException {
        Connection con = null;
        Vector<Persona> personas = new Vector<Persona>();
        try {
            con = conexionDB.openConexion();
            consultasPersona.setConexion(con);
            consultasRol.setConexion(con);
            consultasEstudiante.setConexion(con);
            personas = consultasPersona.leerVariosPersonaPorIdRol(idRol);
            for (Persona persona : personas) {
                Vector<Rol> roles = consultasRol.leerVariosRolPorIdPersona(persona.getIdPersona());
                persona.setRoles(roles);
                for (Rol rol : roles) {
                    if (rol.getRol().equals("Estudiante")) {
                        persona.setMatricula(consultasEstudiante.leerEstudiante(persona.getIdPersona()).getMatricula());
                    }
                }
            }

        } catch (SQLException ex) {
            Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            try {
                con.close();
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return personas;
    }

    public Vector<Rol> leerVariosRolPorIdPersona(int idPersona) throws SQLException {
        Connection con = null;
        Vector<Rol> roles = new Vector<Rol>();
        try {
            con = conexionDB.openConexion();
            consultasRol.setConexion(con);
            roles = consultasRol.leerVariosRolPorIdPersona(idPersona);

        } catch (SQLException ex) {
            Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            try {
                con.close();
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return roles;
    }

    public boolean isUsuarioMiembrodeRol(int idPersona, String nombreRol)throws SQLException {
        Vector <Rol> roles = leerVariosRolPorIdPersona(idPersona);
        for (Rol rol : roles) {
            if(rol.getRol().equals(nombreRol)){
                return true;
            }
        }
        return false;
    }

    public Persona leerPersonaPorUsuario(String usuario) throws SQLException {
        Persona persona = null;
        Connection con = null;
        try {
            con = conexionDB.openConexion();
            consultasPersona.setConexion(con);
            persona = consultasPersona.leerPersonaPorUsuario(usuario, -1);
        } finally {
            try {
                con.close();
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return persona;
    }

    public Profesor leerProfesorPorUsuario(String usuario) throws SQLException {
        Connection con = null;
        Profesor profesor = null;
        try {
            con = conexionDB.openConexion();
            consultasProfesor.setConexion(con);
            profesor = consultasProfesor.leerProfesorPorUsuario(-1, usuario);
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return profesor;
    }

    public Vector<Profesor> buscarProfesor(String criterio) throws SQLException {
        Connection con = null;
        Vector<Profesor> listaProfesor = new Vector<Profesor>();
        Persona persona;
        try {
            con = conexionDB.openConexion();
            consultasProfesor.setConexion(con);
            consultasPersona.setConexion(con);
            listaProfesor = consultasProfesor.leerVariosProfesor(criterio);
            for (Profesor profesor : listaProfesor) {
                persona = consultasPersona.leerPersona(profesor.getIdProfesor());
                profesor.setPersona(persona);
            }
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return listaProfesor;
    }

    public Vector<Persona> buscarPersona(String criterio) throws SQLException {
        Connection con = null;
        Vector<Persona> listaPersona = new Vector<Persona>();
        try {
            con = conexionDB.openConexion();
            consultasPersona.setConexion(con);
            listaPersona = consultasPersona.leerVariosPersona(criterio);
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return listaPersona;
    }

    public Vector<Persona> buscarPersonaConRol(String criterio) throws SQLException {
        Connection con = null;
        Vector<Persona> listaPersona = new Vector<Persona>();
        Vector<Rol> roles;
        try {
            con = conexionDB.openConexion();
            consultasPersona.setConexion(con);
            consultasRol.setConexion(con);
            listaPersona = consultasPersona.leerVariosPersona(criterio);

            for (Persona persona : listaPersona) {
                roles = consultasRol.leerVariosRolPorIdPersona(persona.getIdPersona());
                persona.setRoles(roles);
            }
        } finally {
            if (con != null) {
                con.close();
            }
        }
        return listaPersona;
    }

    public Estudiante leerEstudiante(int idEstudiante) throws SQLException {
        Connection con = null;
        Estudiante estudiante = null;
        try {
            con = conexionDB.openConexion();
            consultasEstudiante.setConexion(con);
            estudiante = consultasEstudiante.leerEstudiante(idEstudiante);

        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return estudiante;
    }

    public Persona leerPersona(int idPersona) throws SQLException {
        Connection con = null;
        Persona persona = null;
        try {
            con = conexionDB.openConexion();
            consultasPersona.setConexion(con);
            persona = consultasPersona.leerPersona(idPersona);

        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return persona;
    }

    public void guardarPersona(Persona persona, Integer[] idRolAsignado) throws SQLException {
        Connection con = null;
        try {
            con = conexionDB.openConexion();
            con.setAutoCommit(false);
            consultasPersona.setConexion(con);
            consultasPersonarol.setConexion(con);

            if (persona.getIdPersona() > 0) {
                consultasPersona.HLmodificarPersona(persona);
            } else {
                persona = consultasPersona.HLnuevoPersona(persona);
            }
            consultasPersonarol.eliminarRolPorPersona(persona.getIdPersona());

            for (int idrol : idRolAsignado) {
                consultasPersonarol.nuevoPersonarol(persona.getIdPersona(), idrol);
            }
            con.commit();
        } finally {
            if (con != null && !con.isClosed()) {
                con.close();
            }
        }
    }

    public void guardarPersona(Persona persona, Vector<Rol> lstRolAsignado) throws SQLException {
        Connection con = null;
        try {
            con = conexionDB.openConexion();
            con.setAutoCommit(false);
            consultasPersona.setConexion(con);
            consultasPersonarol.setConexion(con);

            if (persona.getIdPersona() > 0) {
                consultasPersona.HLmodificarPersona(persona);
            } else {
                persona = consultasPersona.HLnuevoPersona(persona);
            }
            consultasPersonarol.eliminarRolPorPersona(persona.getIdPersona());

            for (Rol rolAsignado : lstRolAsignado) {
                consultasPersonarol.nuevoPersonarol(persona.getIdPersona(), rolAsignado.getIdRol());
            }
            con.commit();
        } finally {
            if (con != null && !con.isClosed()) {
                con.close();
            }
        }
    }

    public Estudiante leerEstudiantePorUsuario(String usuario) throws SQLException {
        Connection con = null;
        Estudiante estudiante = null;
        try {
            con = conexionDB.openConexion();
            consultasEstudiante.setConexion(con);
            consultasPersona.setConexion(con);
            estudiante = consultasEstudiante.leerEstudiantePorUsuario(-1, usuario);

        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return estudiante;
    }

    public Profesor leerProfesorPorCarrera(int idCarrera) throws SQLException {
        Connection con = null;
        Profesor profesor = null;
        Profesorcarrera profesorcarrera = new Profesorcarrera();
        try {
            con = conexionDB.openConexion();
            consultasProfesorcarrera.setConexion(con);
            consultasProfesor.setConexion(con);
            consultasPersona.setConexion(con);
            profesorcarrera = consultasProfesorcarrera.leerProfesorcarreraPorIdCarrera(idCarrera);
            if (profesorcarrera != null) {
                profesor = consultasProfesor.leerProfesor(profesorcarrera.getFkIdProfesor());
                Persona persona = consultasPersona.leerPersona(profesor.getIdProfesor());
                profesor.setPersona(persona);
            }

        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return profesor;
    }

    public Vector<Rol> leerRoles() throws SQLException {
        Vector<Rol> listaRoles = new Vector<Rol>();
        Connection con = null;
        try {
            con = conexionDB.openConexion();
            consultasRol.setConexion(con);
            listaRoles = consultasRol.leerVariosRol();
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return listaRoles;
    }

    public Rol leerRol(int idRol) throws SQLException {
        Connection con = null;
        Rol rol = null;
        try {
            con = conexionDB.openConexion();
            consultasRol.setConexion(con);
            rol = consultasRol.leerRol(idRol);

        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return rol;
    }
// </editor-fold>
// <editor-fold defaultstate="collapsed" desc="Metodos de consultas DatosFinancieros"> 

    public Datosfinancieros nuevoDatosFinancieros(Datosfinancieros datosfinancieros) throws SQLException, Exception {
        Connection con = null;
        Datosfinancieros nuevosDatosFinancieros = null;
        try {
            con = conexionDB.openConexion();
            con.setAutoCommit(false);
            consultasDatosfinancieros.setConexion(con);
            nuevosDatosFinancieros = consultasDatosfinancieros.HLnuevoDatosfinancieros(datosfinancieros);
            con.commit();
        } catch (Exception ex) {
            if (con != null) {
                con.rollback();
            }
            throw ex;
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return nuevosDatosFinancieros;
    }

    public void guardarDatosFinancieros(Datosfinancieros datosfinancieros) throws SQLException, Exception {
        Connection con = null;
        try {
            con = conexionDB.openConexion();
            con.setAutoCommit(false);
            consultasDatosfinancieros.setConexion(con);
            consultasDatosfinancieros.HLmodificarDatosfinancieros(datosfinancieros);
            con.commit();
        } catch (Exception ex) {
            if (con != null) {
                con.rollback();
            }
            throw ex;
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }

    // </editor-fold>
    // <editor-fold defaultstate="collapsed" desc="Metodos de genercion de contrato y manejo xml">
    // </editor-fold>
    // <editor-fold defaultstate="collapsed" desc="Metodos de consultas SolicitudCambioCarreraoEspecializacion">
    public class LogCambioCarrera {

        public LogCambioCarrera() {
        }

        public Solicitudcambiocarrera nuevoSolicitudCambio(Solicitudcambiocarrera solicitudcambio) throws SQLException, Exception {
            Connection con = null;
            Solicitudcambiocarrera nuevaSolicitudcambio = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudcambiocarrera.setConexion(con);
                nuevaSolicitudcambio = consultasSolicitudcambiocarrera.HLnuevoSolicitudcambiocarrera(solicitudcambio);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return nuevaSolicitudcambio;
        }

        public Solicitudcambiocarrera clonarSolicitudCambio(Solicitudcambiocarrera solicitudcambio) throws SQLException, Exception {
            Connection con = null;
            Solicitudcambiocarrera cloneSolicitudcambio = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudcambiocarrera.setConexion(con);
                int fkParent = solicitudcambio.getFkParent();
                solicitudcambio.setFkParent(solicitudcambio.getIdSolicitudCambioCarrera());
                cloneSolicitudcambio = consultasSolicitudcambiocarrera.HLnuevoSolicitudcambiocarrera(solicitudcambio);
                solicitudcambio.setFkParent(fkParent);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return cloneSolicitudcambio;
        }

        public Solicitudcambiocarrera leerSolicitudCambio(int idSolicitud) throws SQLException {
            Connection con = null;
            Solicitudcambiocarrera solicitud = null;
            try {
                con = conexionDB.openConexion();
                consultasSolicitudcambiocarrera.setConexion(con);
                solicitud = consultasSolicitudcambiocarrera.leerSolicitudcambiocarrera(idSolicitud);
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitud;

        }

        public Solicitudcambiocarrera leerSolicitudCambioNivel2(int idSolicitud) throws SQLException {
            Solicitudcambiocarrera solicitud = null;
            Connection con = null;
            try {
                con = conexionDB.openConexion();
                consultasSolicitudcambiocarrera.setConexion(con);
                consultasParametro.setConexion(con);
                consultasProfesor.setConexion(con);
                consultasPersona.setConexion(con);
                consultasEstudiante.setConexion(con);
                solicitud = consultasSolicitudcambiocarrera.leerSolicitudcambiocarrera(idSolicitud);
                solicitud = leerSolicitudCambioNivel2(solicitud);
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitud;
        }

        private Solicitudcambiocarrera leerSolicitudCambioNivel2(Solicitudcambiocarrera solicitud) throws SQLException {
            String temp;
            if (solicitud.getFkIdCarreraActual() != 0) {
                Parametro carreraActual;
                carreraActual = consultasParametro.leerParametro(solicitud.getFkIdCarreraActual());
                if (carreraActual.getFkIdParent() != 0) {
                    temp = consultasParametro.leerParametro(carreraActual.getFkIdParent()).getNombre();
                    temp += " especialización " + carreraActual.getNombre();
                    carreraActual.setNombre(temp);
                }
                solicitud.setCarreraActual(carreraActual);
            }
            if (solicitud.getFkIdCarreraNueva() != 0) {
                Parametro carreraNueva;
                carreraNueva = consultasParametro.leerParametro(solicitud.getFkIdCarreraNueva());
                if (carreraNueva.getFkIdParent() != 0) {
                    temp = consultasParametro.leerParametro(carreraNueva.getFkIdParent()).getNombre();
                    temp += " especialización " + carreraNueva.getNombre();
                    carreraNueva.setNombre(temp);
                }
                solicitud.setCarreraNueva(carreraNueva);
            }
            Estudiante estudiante;
            Persona personaEstudiate;
            estudiante = consultasEstudiante.leerEstudiante(solicitud.getFkidestudiante());
            personaEstudiate = consultasPersona.leerPersona(estudiante.getIdEstudiante());
            estudiante.setPersona(personaEstudiate);
            solicitud.setEstudiante(estudiante);
            Profesor profesor;
            Persona personaProfesor, personaSubdecano, personaSecretaria;
            if (solicitud.getFkIdProfesor() != 0) {
                profesor = consultasProfesor.leerProfesor(solicitud.getFkIdProfesor());
                personaProfesor = consultasPersona.leerPersona(profesor.getIdProfesor());
                profesor.setPersona(personaProfesor);
                solicitud.setProfesor(profesor);
            }
            if (solicitud.getFkIdSubDecano() != 0) {
                profesor = consultasProfesor.leerProfesor(solicitud.getFkIdSubDecano());
                personaSubdecano = consultasPersona.leerPersona(profesor.getIdProfesor());
                profesor.setPersona(personaSubdecano);
                solicitud.setSubDecano(profesor);
            }
            if (solicitud.getFkIdSecretaria() != 0) {
                personaSecretaria = consultasPersona.leerPersona(solicitud.getFkIdSecretaria());
                solicitud.setSecretaria(personaSecretaria);
            }
            return solicitud;
        }

        public Solicitudcambiocarrera guardarYClonarSolicitudCambio(Solicitudcambiocarrera solicitud) throws SQLException, Exception {
            Connection con = null;
            Solicitudcambiocarrera cloneSolicitudCambio = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudcambiocarrera.setConexion(con);
                consultasSolicitudcambiocarrera.HLmodificarSolicitudcambiocarrera(solicitud);
                int fkParent = solicitud.getFkParent();
                solicitud.setFkParent(solicitud.getIdSolicitudCambioCarrera());
                cloneSolicitudCambio = consultasSolicitudcambiocarrera.HLnuevoSolicitudcambiocarrera(solicitud);
                solicitud.setFkParent(fkParent);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return cloneSolicitudCambio;
        }

        public Solicitudcambiocarrera leerSolicitudCambio(int idEstudiante, String estado) throws SQLException {
            Connection con = null;
            Solicitudcambiocarrera solicitud = null;
            try {
                con = conexionDB.openConexion();
                consultasSolicitudcambiocarrera.setConexion(con);
                solicitud = consultasSolicitudcambiocarrera.leerSolicitudcambiocarrera(idEstudiante, estado);
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitud;

        }
    }
    // </editor-fold >
    // <editor-fold defaultstate="collapsed" desc="Metodos de consultas SolicitudConvalidacionMateria">

    public class LogConvalidacionMateria {

        public LogConvalidacionMateria() {
        }

        public Solicitudconvalidacionmateria clonarSolicitudConvalidacion(Solicitudconvalidacionmateria solicitud) throws SQLException, Exception {
            Connection con = null;
            Solicitudconvalidacionmateria cloneSolicitudconvalicacion = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudconvalidacionmateria.setConexion(con);
                int fkParent = solicitud.getFkParent();
                solicitud.setFkParent(solicitud.getIdSolicitudConvalidacion());
                cloneSolicitudconvalicacion = consultasSolicitudconvalidacionmateria.HLnuevoSolicitudconvalidacionmateria(solicitud);
                solicitud.setFkParent(fkParent);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return cloneSolicitudconvalicacion;
        }

        public Solicitudconvalidacionmateria guardarYClonarSolicitudConvalidacion(Solicitudconvalidacionmateria solicitud) throws SQLException, Exception {
            Connection con = null;
            Solicitudconvalidacionmateria cloneSolicitudConvalidacion = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudconvalidacionmateria.setConexion(con);
                consultasSolicitudconvalidacionmateria.HLmodificarSolicitudconvalidacionmateria(solicitud);
                int fkParent = solicitud.getFkParent();
                solicitud.setFkParent(solicitud.getIdSolicitudConvalidacion());
                cloneSolicitudConvalidacion = consultasSolicitudconvalidacionmateria.HLnuevoSolicitudconvalidacionmateria(solicitud);
                solicitud.setFkParent(fkParent);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return cloneSolicitudConvalidacion;
        }

        public Solicitudconvalidacionmateria leerSolicitudConvalidacion(int idSolicitud) throws SQLException {
            Connection con = null;
            Solicitudconvalidacionmateria solicitud = null;
            try {
                con = conexionDB.openConexion();
                consultasSolicitudconvalidacionmateria.setConexion(con);
                solicitud = consultasSolicitudconvalidacionmateria.leerSolicitudconvalidacionmateria(idSolicitud);
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitud;
        }

        public Solicitudconvalidacionmateria leerSolicitudConvalidacion(int idEstudiante, String estado, int idMateria) throws SQLException {
            Connection con = null;
            Solicitudconvalidacionmateria solicitud = null;
            try {
                con = conexionDB.openConexion();
                consultasSolicitudconvalidacionmateria.setConexion(con);
                solicitud = consultasSolicitudconvalidacionmateria.leerSolicitudconvalidacionmateria(idEstudiante, estado, idMateria);
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitud;

        }

        public Solicitudconvalidacionmateria leerSolicitudConvalidacionNivel2(int idSolicitud) throws SQLException {
            Solicitudconvalidacionmateria solicitud = null;
            Connection con = null;
            try {
                con = conexionDB.openConexion();
                consultasSolicitudconvalidacionmateria.setConexion(con);
                consultasMateria.setConexion(con);
                consultasProfesor.setConexion(con);
                consultasPersona.setConexion(con);
                consultasEstudiante.setConexion(con);
                solicitud = consultasSolicitudconvalidacionmateria.leerSolicitudconvalidacionmateria(idSolicitud);
                solicitud = leerSolicitudConvalidacionNivel2(solicitud);
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitud;
        }

        private Solicitudconvalidacionmateria leerSolicitudConvalidacionNivel2(Solicitudconvalidacionmateria solicitud) throws SQLException {
            if (solicitud.getFkIdMateria() != 0) {
                Materia materia;
                materia = consultasMateria.leerMateria(solicitud.getFkIdMateria());
                solicitud.setMateria(materia);
            }

            Estudiante estudiante;
            Persona personaEstudiante;
            estudiante = consultasEstudiante.leerEstudiante(solicitud.getFkIdEstudiante());
            personaEstudiante = consultasPersona.leerPersona(estudiante.getIdEstudiante());
            estudiante.setPersona(personaEstudiante);
            solicitud.setEstudiante(estudiante);

            Profesor profesor;
            Persona personaProfesor, personaSubdecano, personaSecretaria;
            if (solicitud.getFkIdProfesor() != 0) {
                profesor = consultasProfesor.leerProfesor(solicitud.getFkIdProfesor());
                personaProfesor = consultasPersona.leerPersona(profesor.getIdProfesor());
                profesor.setPersona(personaProfesor);
                solicitud.setProfesor(profesor);
            }
            if (solicitud.getFkIdSubDecano() != 0) {
                profesor = consultasProfesor.leerProfesor(solicitud.getFkIdSubDecano());
                personaSubdecano = consultasPersona.leerPersona(profesor.getIdProfesor());
                profesor.setPersona(personaSubdecano);
                solicitud.setSubDecano(profesor);
            }
            if (solicitud.getFkIdSecretaria() != 0) {
                personaSecretaria = consultasPersona.leerPersona(solicitud.getFkIdSecretaria());
                solicitud.setSecretaria(personaSecretaria);
            }

            return solicitud;
        }

        public Solicitudconvalidacionmateria nuevoSolicitudConvalidacion(Solicitudconvalidacionmateria solicitud) throws SQLException, Exception {
            Connection con = null;
            Solicitudconvalidacionmateria nuevaSolicitudcambio = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudconvalidacionmateria.setConexion(con);
                nuevaSolicitudcambio = consultasSolicitudconvalidacionmateria.HLnuevoSolicitudconvalidacionmateria(solicitud);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return nuevaSolicitudcambio;
        }
    }
    // </editor-fold>
    // <editor-fold defaultstate="collapsed" desc="Metodos de consultas SolicitudAperturaTopico">

    public class LogAperturaPostgrado {

        public LogAperturaPostgrado() {
        }

        public Solicitudaperturapostgrado nuevoSolicitudApertura(Solicitudaperturapostgrado solicitudapertura) throws SQLException, Exception {
            Connection con = null;
            Solicitudaperturapostgrado nuevaSolicitudapertura = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudaperturapostgrado.setConexion(con);
                nuevaSolicitudapertura = consultasSolicitudaperturapostgrado.HLnuevoSolicitudaperturapostgrado(solicitudapertura);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return nuevaSolicitudapertura;
        }

        public Solicitudaperturapostgrado clonarSolicitudApertura(Solicitudaperturapostgrado solicitudapertura) throws SQLException, Exception {
            Connection con = null;
            Solicitudaperturapostgrado cloneSolicitudapertura = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudaperturapostgrado.setConexion(con);
                int fkParent = solicitudapertura.getFkParent();
                solicitudapertura.setFkParent(solicitudapertura.getIdSolicitudApertura());
                cloneSolicitudapertura = consultasSolicitudaperturapostgrado.HLnuevoSolicitudaperturapostgrado(solicitudapertura);
                solicitudapertura.setFkParent(fkParent);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return cloneSolicitudapertura;
        }

        public Solicitudaperturapostgrado leerSolicitudApertura(int idSolicitud) throws SQLException {
            Connection con = null;
            Solicitudaperturapostgrado solicitud = null;
            try {
                con = conexionDB.openConexion();
                consultasSolicitudaperturapostgrado.setConexion(con);
                solicitud = consultasSolicitudaperturapostgrado.leerSolicitudaperturapostgrado(idSolicitud);
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitud;

        }

        public Solicitudaperturapostgrado leerSolicitudAperturaNivel2(int idSolicitud) throws SQLException {
            Solicitudaperturapostgrado solicitud = null;
            Connection con = null;
            try {
                con = conexionDB.openConexion();
                consultasSolicitudaperturapostgrado.setConexion(con);
                consultasProfesor.setConexion(con);
                consultasPersona.setConexion(con);

                solicitud = consultasSolicitudaperturapostgrado.leerSolicitudaperturapostgrado(idSolicitud);
                solicitud = leerSolicitudAperturaNivel2(solicitud);
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitud;
        }

        private Solicitudaperturapostgrado leerSolicitudAperturaNivel2(Solicitudaperturapostgrado solicitud) throws SQLException {
            Profesor profesor;
            Persona personaProfesor, personaDecano, personaSecretaria;

            if (solicitud.getFkIdProfesor() != 0) {
                profesor = consultasProfesor.leerProfesor(solicitud.getFkIdProfesor());
                personaProfesor = consultasPersona.leerPersona(profesor.getIdProfesor());
                profesor.setPersona(personaProfesor);
                solicitud.setProfesor(profesor);
            }
            if (solicitud.getFkIdEvaluador1() != 0) {
                profesor = consultasProfesor.leerProfesor(solicitud.getFkIdEvaluador1());
                personaProfesor = consultasPersona.leerPersona(profesor.getIdProfesor());
                profesor.setPersona(personaProfesor);
                solicitud.setEvaluador1(profesor);
            }
            if (solicitud.getFkIdEvaluador2() != 0) {
                profesor = consultasProfesor.leerProfesor(solicitud.getFkIdEvaluador2());
                personaProfesor = consultasPersona.leerPersona(profesor.getIdProfesor());
                profesor.setPersona(personaProfesor);
                solicitud.setEvaluador2(profesor);
            }
            if (solicitud.getFkIdEvaluador3() != 0) {
                profesor = consultasProfesor.leerProfesor(solicitud.getFkIdEvaluador3());
                personaProfesor = consultasPersona.leerPersona(profesor.getIdProfesor());
                profesor.setPersona(personaProfesor);
                solicitud.setEvaluador3(profesor);
            }
            if (solicitud.getFkIdDecano() != 0) {
                profesor = consultasProfesor.leerProfesor(solicitud.getFkIdDecano());
                personaDecano = consultasPersona.leerPersona(profesor.getIdProfesor());
                profesor.setPersona(personaDecano);
                solicitud.setDecano(profesor);
            }

            if (solicitud.getFkIdSecretaria() != 0) {
                personaSecretaria = consultasPersona.leerPersona(solicitud.getFkIdSecretaria());
                solicitud.setSecretaria(personaSecretaria);
            }
            return solicitud;
        }

        public Solicitudaperturapostgrado guardarYClonarSolicitudApertura(Solicitudaperturapostgrado solicitud) throws SQLException, Exception {
            Connection con = null;
            Solicitudaperturapostgrado cloneSolicitudApertura = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudaperturapostgrado.setConexion(con);
                consultasSolicitudaperturapostgrado.HLmodificarSolicitudaperturapostgrado(solicitud);
                int fkParent = solicitud.getFkParent();
                solicitud.setFkParent(solicitud.getIdSolicitudApertura());
                cloneSolicitudApertura = consultasSolicitudaperturapostgrado.HLnuevoSolicitudaperturapostgrado(solicitud);
                solicitud.setFkParent(fkParent);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return cloneSolicitudApertura;
        }
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="Metodos de consultas SolicitudAperturaPostgrado">
    public class LogAperturaTopico {

        public LogAperturaTopico() {
        }

        public Solicitudaperturatopico nuevoSolicitudApertura(Solicitudaperturatopico solicitudapertura) throws SQLException, Exception {
            Connection con = null;
            Solicitudaperturatopico nuevaSolicitudapertura = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudaperturatopico.setConexion(con);
                nuevaSolicitudapertura = consultasSolicitudaperturatopico.HLnuevoSolicitudaperturatopico(solicitudapertura);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return nuevaSolicitudapertura;
        }

        public Solicitudaperturatopico clonarSolicitudApertura(Solicitudaperturatopico solicitudapertura) throws SQLException, Exception {
            Connection con = null;
            Solicitudaperturatopico cloneSolicitudapertura = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudaperturatopico.setConexion(con);
                int fkParent = solicitudapertura.getFkParent();
                solicitudapertura.setFkParent(solicitudapertura.getIdSolicitudApertura());
                cloneSolicitudapertura = consultasSolicitudaperturatopico.HLnuevoSolicitudaperturatopico(solicitudapertura);
                solicitudapertura.setFkParent(fkParent);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return cloneSolicitudapertura;
        }

        public Solicitudaperturatopico leerSolicitudApertura(int idSolicitud) throws SQLException {
            Connection con = null;
            Solicitudaperturatopico solicitud = null;
            try {
                con = conexionDB.openConexion();
                consultasSolicitudaperturatopico.setConexion(con);
                solicitud = consultasSolicitudaperturatopico.leerSolicitudaperturatopico(idSolicitud);
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitud;

        }

        public Solicitudaperturatopico leerSolicitudAperturaNivel2(int idSolicitud) throws SQLException {
            Solicitudaperturatopico solicitud = null;
            Connection con = null;
            try {
                con = conexionDB.openConexion();
                consultasSolicitudaperturatopico.setConexion(con);
                consultasProfesor.setConexion(con);
                consultasPersona.setConexion(con);

                solicitud = consultasSolicitudaperturatopico.leerSolicitudaperturatopico(idSolicitud);
                solicitud = leerSolicitudAperturaNivel2(solicitud);
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitud;
        }

        private Solicitudaperturatopico leerSolicitudAperturaNivel2(Solicitudaperturatopico solicitud) throws SQLException {
            Profesor profesor;
            Persona personaProfesor, personaDecano;
            if (solicitud.getFkIdProfesor() != 0) {
                profesor = consultasProfesor.leerProfesor(solicitud.getFkIdProfesor());
                personaProfesor = consultasPersona.leerPersona(profesor.getIdProfesor());
                profesor.setPersona(personaProfesor);
                solicitud.setProfesor(profesor);
            }
            if (solicitud.getFkIdEvaluador1() != 0) {
                profesor = consultasProfesor.leerProfesor(solicitud.getFkIdEvaluador1());
                personaProfesor = consultasPersona.leerPersona(profesor.getIdProfesor());
                profesor.setPersona(personaProfesor);
                solicitud.setEvaluador1(profesor);
            }
            if (solicitud.getFkIdEvaluador2() != 0) {
                profesor = consultasProfesor.leerProfesor(solicitud.getFkIdEvaluador2());
                personaProfesor = consultasPersona.leerPersona(profesor.getIdProfesor());
                profesor.setPersona(personaProfesor);
                solicitud.setEvaluador2(profesor);
            }
            if (solicitud.getFkIdEvaluador3() != 0) {
                profesor = consultasProfesor.leerProfesor(solicitud.getFkIdEvaluador3());
                personaProfesor = consultasPersona.leerPersona(profesor.getIdProfesor());
                profesor.setPersona(personaProfesor);
                solicitud.setEvaluador3(profesor);
            }
            if (solicitud.getFkIdDecano() != 0) {
                profesor = consultasProfesor.leerProfesor(solicitud.getFkIdDecano());
                personaDecano = consultasPersona.leerPersona(profesor.getIdProfesor());
                profesor.setPersona(personaDecano);
                solicitud.setDecano(profesor);
            }
            return solicitud;
        }

        public Solicitudaperturatopico guardarYClonarSolicitudApertura(Solicitudaperturatopico solicitud) throws SQLException, Exception {
            Connection con = null;
            Solicitudaperturatopico cloneSolicitudApertura = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudaperturatopico.setConexion(con);
                consultasSolicitudaperturatopico.HLmodificarSolicitudaperturatopico(solicitud);
                int fkParent = solicitud.getFkParent();
                solicitud.setFkParent(solicitud.getIdSolicitudApertura());
                cloneSolicitudApertura = consultasSolicitudaperturatopico.HLnuevoSolicitudaperturatopico(solicitud);
                solicitud.setFkParent(fkParent);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return cloneSolicitudApertura;
        }
    }
    // </editor-fold>

    public class LogAyudantia {

        public LogAyudantia() {
        }
        //falta enviar correos notificando que se

        public String generarConvocatoria(Solicitudayudantia solicitudAyudantia) throws MensajeException {
            TipoAyudantia tipoAyudantia = leerTipoAyudantia(solicitudAyudantia);
            String nombreAyudantia = "";
            String ayudantia = "";
            String requisitosEspol = "";
            String archivoAdjunto = "";
            String message = "";
            String responsable = "";
            String numAyudantes = "";
            String requisitosAdicionales = "";
            String requisitosAdicionales2 = "";
            Configuracion configuracionRequisitos;
            try {
                if (tipoAyudantia.getTipo() == TipoAyudantiaEnum.ACADEMICA) {
                    nombreAyudantia = solicitudAyudantia.getMateria().getNombre();
                    ayudantia = "Ayudantía " + tipoAyudantia.getNombre() + " para la materia " + nombreAyudantia;
                    configuracionRequisitos = leerConfiguracionPorNombre(Constantes.Configuracion.AyudantiasAcademicas.getNombreEnBD());
                } else {
                    nombreAyudantia = solicitudAyudantia.getAyudantiavaria().getNombre();
                    ayudantia = "Ayudantía " + "de " + tipoAyudantia.getNombre() + " para " + nombreAyudantia;
                    configuracionRequisitos = leerConfiguracionPorNombre(Constantes.Configuracion.AyudantiasVarias.getNombreEnBD());
                }
                String anuncio = "Se anuncia a los estudiantes de la Facultad de Ingenieria en Electricidad y Computacion " +
                        "la apertura del Concurso de " + ayudantia + ".";
                String actividad = " la actividad a realizar por los ayudantes sera: " + solicitudAyudantia.getActividadarealizar();
                if (solicitudAyudantia.getNumAyudantesHoras() != null) {
                    numAyudantes = " Se seleccionaran " + solicitudAyudantia.getNumAyudantesHoras() + ".";
                }
                String pattern = "dd/MM/yyyy";
                SimpleDateFormat sdf = new SimpleDateFormat();
                sdf.applyPattern(pattern);
                String recepcion = "Las solicitudes deberan ser enviadas a través del Sistema Solicitudes FIEC hasta el " + sdf.format(solicitudAyudantia.getFechafinayudantia()) + ".";
                String lapsoAyudantia = "La ayudantia durara desde el " + sdf.format(solicitudAyudantia.getFechainicioayudantia()) + " hasta el " +
                        sdf.format(solicitudAyudantia.getFechafinayudantia()) + " y ";

                String reglamentoBecas = "Los aspirantes deberan cumplir con el Reglamento de Becas de la ESPOL.";
                requisitosEspol = configuracionRequisitos.getDescripcion().replaceAll("\n", "<br)>");

                if (solicitudAyudantia.getRequisitosAdicionales() != null) {
                    requisitosAdicionales = "Adicionalmente, los aspirantes deberan cumplir los siguientes requisitos:";
                    requisitosAdicionales2 = solicitudAyudantia.getRequisitosAdicionales().replaceAll("\n", "<br/>");
                }
                if (solicitudAyudantia.getRequiereAdjunto()) {
                    archivoAdjunto = "Adjuntar " + solicitudAyudantia.getTipoArchivo() + ".";
                }
                responsable = "Atentamente, <br/><br/> " + solicitudAyudantia.getProfesor().getPersona().toString() + "<br/>" + "Docente FIEC";
                message = ayudantia +
                        "<br/><br/>" + anuncio +
                        "<br/><br/>" + lapsoAyudantia +
                        actividad +
                        "<br/><br/>" + recepcion + numAyudantes +
                        "<br/><br/>" + reglamentoBecas +
                        "<br/>" + requisitosEspol +
                        "<br/><br/>" + requisitosAdicionales +
                        "<br/>" + requisitosAdicionales2 +
                        "<br/><br/>" + archivoAdjunto +
                        "<br/><br/>" + responsable;
            } catch (Exception ex) {
                ex.printStackTrace();
                throw new MensajeException(Constantes.Mensajes.noMuestra);
            }
            return message;
        }

        // <editor-fold defaultstate="collapsed" desc="Metodos de procesos SolicitudAyudantias">
        public void cancelarProcesosSolicitarSerAyudante(Solicitudayudantia solicitudayudantia) throws NamingException, CreateException, RemoteException, HeroException, Exception {

            Vector<Solicitudserayudante> listaSolicitudSerAyudante = solicitudayudantia.getListaSolicitudserayudante();
            ProjectSessionHome prjHome = (ProjectSessionHome) ProjectSessionUtil.getHome();
            UserSessionHome usrHome = (UserSessionHome) UserSessionUtil.getHome();
            ProjectSession prjSession = prjHome.create();
            UserSession usrSession = usrHome.create();
            String nombreActividadAprob = Constantes.SolicitarSerAyudante.revisarSolicitud; //no seleccionados
            //los que aceptaron y rechazaron ya terminaron con sus procesos.
//            String nombreActividadContrat = Constantes.SolicitarSerAyudante.confirmarAceptacion; //
            String nombreActividadProrroga = Constantes.SolicitarSerAyudante.prorrogarConfirmacion; //no contestaron

            BnNodeValue actividad;
            Solicitudserayudante solicitudserayudante;
            String nombreActividad;
            for (Solicitudserayudante object : listaSolicitudSerAyudante) {
                nombreActividad = "";
                String nombreInstanciaProceso = object.getNombreinstanciaproceso();
                usrSession.getModelInstancesTodoList(nombreInstanciaProceso);
                prjSession.initProject(nombreInstanciaProceso);
                String nombreDecision = "", valorDecision = "";
                if (object.getSeleccionado()) {
                    if (object.getRespuestaConfirmacion().equals(Constantes.Atributo.DecisionConfirmacion.Rechazar.toString()) ||
                            object.getRespuestaConfirmacion().equals(Constantes.Atributo.DecisionConfirmacion.Aceptar.toString())) {
                        //las instancias de los que rechazaron y aceptaron ya finalizaron
                        continue;
                    }
                    if (object.getRespuestaConfirmacion().equals(Constantes.Atributo.DecisionConfirmacion.NoContestar.toString())) {
                        nombreActividad = nombreActividadProrroga;
                        nombreDecision = Constantes.Atributo.decisionProrrogar;
                        valorDecision = Constantes.Atributo.DecisionProrrogar.Cancelar.toString();
                    }
                } else {
                    nombreActividad = nombreActividadAprob;
                    nombreDecision = Constantes.Atributo.decisionRevision;
                    valorDecision = Constantes.Atributo.Decision.Cancelar.toString();
                }
                actividad = usrSession.getNode(nombreInstanciaProceso, nombreActividad);
                if (!(actividad != null && (actividad.getState() == hero.interfaces.Constants.Nd.READY || actividad.getState() == hero.interfaces.Constants.Nd.ANTICIPABLE))) {
                    throw new Exception();
                }

//                object.setFechamodificacion(new java.sql.Timestamp(fecha.getTime()));
                object.setEstado(Constantes.EstadoSolicitud.Cancelada.toString());
                solicitudserayudante = guardarYClonarSolicitudserayudante(object);
                prjSession.setNodeProperty(nombreActividad, Constantes.Atributo.idSolicitudActividad, solicitudserayudante.getIdSolicitudSerAyudante() + "");
                prjSession.setNodeProperty(nombreActividad, nombreDecision, valorDecision);
                usrSession.startActivity(nombreInstanciaProceso, nombreActividad);
                usrSession.terminateActivity(nombreInstanciaProceso, nombreActividad);

                //enviar mail de notificacion
                String tipoAyudantia = "";
                if (solicitudayudantia.getFkIdAyudantiaVaria() != 0) {
                    tipoAyudantia = "Actividades varias";
                }
                if (solicitudayudantia.getFkIdMateria() != 0) {
                    tipoAyudantia = "Académica";
                }
                String to = leerPersona(object.getFkIdEstudiante()).getCorreo();
                String subject = Constantes.MensajesCorreo.tituloCorreo + "Cancelación de concurso de ayudantía de " + solicitudayudantia.toString();
                String message = Constantes.TipoSolicitud.Ayudantia + "_" + solicitudayudantia.getIdSolicitudAyudantia() +
                        "\n\n" + "Título: Ayudantía " + tipoAyudantia + " " + solicitudayudantia.toString() + "\n" +
                        "Solicitante: " + leerPersona(solicitudayudantia.getFkIdProfesor()).toString() + "\n\n" +
                        "El profesor solicitante ha decidido cancelar el concurso de ayudantía." +
                        Constantes.MensajesCorreo.referenciaSistema;
                SendMailEspol sendMail = new SendMailEspol(to, subject, message);
                sendMail.send();
            }
        }

        public void terminarProcesosSolicitarSerAyudante(Solicitudayudantia solicitudayudantia, int idSolicitudActividad) throws NamingException, CreateException, RemoteException, HeroException, Exception {
            Vector<Solicitudserayudante> listaSolicitudSerAyudante = solicitudayudantia.getListaSolicitudserayudante();
            ProjectSessionHome prjHome = (ProjectSessionHome) ProjectSessionUtil.getHome();
            UserSessionHome usrHome = (UserSessionHome) UserSessionUtil.getHome();
            ProjectSession prjSession = prjHome.create();
            UserSession usrSession = usrHome.create();
            String nombreActividadAprob = Constantes.SolicitarSerAyudante.revisarSolicitud; //no seleccionados
            //las instancias de los que rechazaron y aceptaron ya finalizaron
//            String nombreActividadContrat = Constantes.SolicitarSerAyudante.confirmarAceptacion;
            String nombreActividadProrroga = Constantes.SolicitarSerAyudante.prorrogarConfirmacion; //no contestaron

            BnNodeValue actividad;
            Solicitudserayudante solicitudserayudante;
            String nombreActividad;
            String nombreDecision = "", valorDecision = "";
            String ayudantes = "";
            for (Solicitudserayudante object : listaSolicitudSerAyudante) {
                if (object.getSeleccionado()) {
                    if (object.getRespuestaConfirmacion().equals(Constantes.Atributo.DecisionConfirmacion.Aceptar.toString())) {
                        ayudantes += leerPersona(object.getFkIdEstudiante()).toString() + "\n";
                    }
                }
            }

            for (Solicitudserayudante object : listaSolicitudSerAyudante) {
                nombreActividad = "";
                String nombreInstanciaProceso = object.getNombreinstanciaproceso();
                usrSession.getModelInstancesTodoList(nombreInstanciaProceso);
                prjSession.initProject(nombreInstanciaProceso);
                if (object.getSeleccionado()) {
                    if (object.getRespuestaConfirmacion().equals(Constantes.Atributo.DecisionConfirmacion.Rechazar.toString()) ||
                            object.getRespuestaConfirmacion().equals(Constantes.Atributo.DecisionConfirmacion.Aceptar.toString())) {
                        //las instancias de los que rechazaron y aceptaron ya finalizaron
                        continue;
                    }
//                    if (object.getRespuestaConfirmacion().equals("Acepto")) {
//                        nombreActividad = nombreActividadContrat;
//                        prjSession.setNodeProperty(nombreActividad, "AyudantiaCancelada", "No");
//                    }
                    if (object.getRespuestaConfirmacion().equals(Constantes.Atributo.DecisionConfirmacion.NoContestar.toString())) {
                        nombreActividad = nombreActividadProrroga;
                        nombreDecision = Constantes.Atributo.decisionProrrogar;
                        valorDecision = Constantes.Atributo.DecisionProrrogar.NoProrrogar.toString();
                    }
                } else {
                    nombreActividad = nombreActividadAprob;
                    nombreDecision = Constantes.Atributo.decisionRevision;
                    valorDecision = Constantes.Atributo.Decision.Rechazar.toString();
                }
                actividad = usrSession.getNode(nombreInstanciaProceso, nombreActividad);
                if (!(actividad != null && (actividad.getState() == hero.interfaces.Constants.Nd.READY || actividad.getState() == hero.interfaces.Constants.Nd.ANTICIPABLE))) {
                    throw new Exception();
                }
                object.setEstado(Constantes.EstadoSolicitud.Terminada.toString());
                this.guardarSolicitudserayudante(object);
                object.setFkIdSolicitudAyudantia(idSolicitudActividad);
//                object.setFechamodificacion(new java.sql.Timestamp(fecha.getTime()));
                solicitudserayudante = clonarSolicitudserayudante(object);
                prjSession.setNodeProperty(nombreActividad, Constantes.Atributo.idSolicitudActividad, solicitudserayudante.getIdSolicitudSerAyudante() + "");
                prjSession.setNodeProperty(nombreActividad, nombreDecision, valorDecision);
                usrSession.startActivity(nombreInstanciaProceso, nombreActividad);
                usrSession.terminateActivity(nombreInstanciaProceso, nombreActividad);

                //enviar mail de notificacion
                String tipoAyudantia = "";
                if (solicitudayudantia.getFkIdAyudantiaVaria() != 0) {
                    tipoAyudantia = "Actividades varias";
                }
                if (solicitudayudantia.getFkIdMateria() != 0) {
                    tipoAyudantia = "Académica";
                }
                String to = leerPersona(object.getFkIdEstudiante()).getCorreo();
                String subject = Constantes.MensajesCorreo.tituloCorreo + "El concurso de ayudantía de " + solicitudayudantia.toString() + " ha finalizado ";
                String message =
                        "Ayudantía " + tipoAyudantia + " " + solicitudayudantia.toString() + "\n" +
                        "Profesor/Responsable: " + leerPersona(solicitudayudantia.getFkIdProfesor()).toString() + "\n\n" +
                        "\n\n" + "El concurso de ayudantía ha finalizado. " +
                        "\n\n" + "Los estudiantes seleccionados son: \n" +
                        ayudantes;
                        SendMailEspol sendMail = new SendMailEspol(to, subject, message);
                sendMail.send();
            }
        }
        // </editor-fold>

        // <editor-fold defaultstate="collapsed" desc="Metodos de consultas SolicitudAyudantia">
        public Solicitudayudantia clonarSolicitudAyudantia(Solicitudayudantia solicitudayudantia) throws SQLException, Exception {
            Connection con = null;
            Solicitudayudantia cloneSolicitudayudantia = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudayudantia.setConexion(con);
                int fkParent = solicitudayudantia.getFkParent();
                solicitudayudantia.setFkParent(solicitudayudantia.getIdSolicitudAyudantia());
                cloneSolicitudayudantia = consultasSolicitudayudantia.HLnuevoSolicitudayudantia(solicitudayudantia);
                solicitudayudantia.setFkParent(fkParent);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return cloneSolicitudayudantia;
        }

        public Solicitudayudantia nuevoSolicitudayudantia(Solicitudayudantia solicitudayudantia) throws SQLException, Exception {
            Connection con = null;
            Solicitudayudantia nuevaSolicitudayudantia = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudayudantia.setConexion(con);
                nuevaSolicitudayudantia = consultasSolicitudayudantia.HLnuevoSolicitudayudantia(solicitudayudantia);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return nuevaSolicitudayudantia;
        }

        public Solicitudayudantia guardarYClonarSolicitudAyudantia(Solicitudayudantia solicitudayudantia) throws Exception {
            Connection con = null;
            Solicitudayudantia cloneSolicitudayudantia = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudayudantia.setConexion(con);
                consultasSolicitudayudantia.HLmodificarSolicitudayudantia(solicitudayudantia);
                int fkParent = solicitudayudantia.getFkParent();
                solicitudayudantia.setFkParent(solicitudayudantia.getIdSolicitudAyudantia());
                cloneSolicitudayudantia = consultasSolicitudayudantia.HLnuevoSolicitudayudantia(solicitudayudantia);
                solicitudayudantia.setFkParent(fkParent);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return cloneSolicitudayudantia;
        }

        public void guardarSolicitudAyudantia(Solicitudayudantia solicitudayudantia) throws SQLException, Exception {
            Connection con = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudayudantia.setConexion(con);
                consultasSolicitudayudantia.HLmodificarSolicitudayudantia(solicitudayudantia);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }

        public Solicitudayudantia leerSolicitudayudantia(int idSolicitudAyudantia) throws SQLException {
            Connection con = null;
            Solicitudayudantia solicitud = null;
            try {
                con = conexionDB.openConexion();
                consultasSolicitudayudantia.setConexion(con);
                solicitud = consultasSolicitudayudantia.leerSolicitudayudantia(idSolicitudAyudantia);
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitud;
        }

        public Solicitudayudantia leerSolicitudayudantiaNivel2(int idSolicitudAyudantia) throws SQLException {
            Solicitudayudantia solicitud = null;
            Connection con = null;
            try {
                con = conexionDB.openConexion();
                consultasSolicitudayudantia.setConexion(con);
                consultasConfiguracion.setConexion(con);
                consultasMateria.setConexion(con);
                consultasProfesor.setConexion(con);
                consultasPersona.setConexion(con);
                consultasParametro.setConexion(con);
                solicitud = consultasSolicitudayudantia.leerSolicitudayudantia(idSolicitudAyudantia);
                solicitud = leerSolicitudayudantiaNivel2(solicitud);
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitud;
        }

        private Solicitudayudantia leerSolicitudayudantiaNivel2(Solicitudayudantia solicitud) throws SQLException {
            Parametro ayudantiaVaria;
            if (solicitud.getFkIdAyudantiaVaria() != 0) {
                ayudantiaVaria = consultasParametro.leerParametro(solicitud.getFkIdAyudantiaVaria());
                solicitud.setAyudantiavaria(ayudantiaVaria);
            }
            Materia materia;
            if (solicitud.getFkIdMateria() != 0) {
                materia = consultasMateria.leerMateria(solicitud.getFkIdMateria());
                solicitud.setMateria(materia);
            }
            Profesor profesor;
            Persona personaProfesor;
            if (solicitud.getFkIdProfesor() != 0) {
                profesor = consultasProfesor.leerProfesor(solicitud.getFkIdProfesor());
                solicitud.setProfesor(profesor);
                personaProfesor = consultasPersona.leerPersona(profesor.getIdProfesor());
                profesor.setPersona(personaProfesor);
            }
            Profesor decano;
            Persona personaDecano;
            if (solicitud.getFkiddecano() != 0) {
                decano = consultasProfesor.leerProfesor(solicitud.getFkiddecano());
                solicitud.setDecano(decano);
                personaDecano = consultasPersona.leerPersona(decano.getIdProfesor());
                decano.setPersona(personaDecano);
            }
            Persona personaSecretaria;
            if (solicitud.getFkIdSecretaria() != 0) {
                personaSecretaria = consultasPersona.leerPersona(solicitud.getFkIdSecretaria());
                solicitud.setSecretaria(personaSecretaria);
            }
            return solicitud;
        }

        public Solicitudayudantia leerSolicitudayudantiaNivel3(int idSolicitudAyudantia) throws SQLException {
            Connection con = null;
            Solicitudayudantia solicitud = null;
            Vector<Solicitudserayudante> listaSolicitudserayudante = new Vector<Solicitudserayudante>();
            Solicitudayudantia solicitudPrimaria;
            try {
                con = conexionDB.openConexion();
                consultasSolicitudayudantia.setConexion(con);
                consultasSolicitudserayudante.setConexion(con);
                consultasEstudiante.setConexion(con);
                consultasPersona.setConexion(con);
                consultasDatosacademicos.setConexion(con);
                consultasDatosfinancieros.setConexion(con);
                consultasConfiguracion.setConexion(con);
                consultasProfesor.setConexion(con);
                consultasMateria.setConexion(con);
                consultasDatosmateria.setConexion(con);
                consultasParametro.setConexion(con);
                solicitudPrimaria = consultasSolicitudayudantia.leerSolicitudayudantia(idSolicitudAyudantia);
                solicitud = leerSolicitudayudantiaNivel2(solicitudPrimaria);
                listaSolicitudserayudante = consultasSolicitudserayudante.leerVariosSolicitudserayudantePorIdSolicitudAyudantia(idSolicitudAyudantia);
                for (Solicitudserayudante solicitudserayudante : listaSolicitudserayudante) {
                    solicitudserayudante.setSolicitudayudantia(solicitudPrimaria);
                    solicitudserayudante = leerSolicitudserayudanteNivel2(solicitudserayudante);
                }
                solicitud.setListaSolicitudserayudante(listaSolicitudserayudante);
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitud;
        }

        public Solicitudayudantia leerSolicitudayudantiaNivel4(int idSolicitudAyudantia) throws SQLException {
            Connection con = null;
            Solicitudayudantia solicitud = null;
            Vector<Solicitudserayudante> listaSolicitudserayudante = new Vector<Solicitudserayudante>();
            try {
                con = conexionDB.openConexion();
                consultasSolicitudayudantia.setConexion(con);
                consultasSolicitudserayudante.setConexion(con);
                consultasEstudiante.setConexion(con);
                consultasPersona.setConexion(con);
                consultasDatosacademicos.setConexion(con);
                consultasDatosfinancieros.setConexion(con);
                consultasConfiguracion.setConexion(con);
                consultasProfesor.setConexion(con);
                consultasMateria.setConexion(con);
                consultasDatosmateria.setConexion(con);
                consultasParametro.setConexion(con);
                solicitud = consultasSolicitudayudantia.leerSolicitudayudantia(idSolicitudAyudantia);
                solicitud = leerSolicitudayudantiaNivel2(solicitud);
                listaSolicitudserayudante = consultasSolicitudserayudante.leerVariosSolicitudserayudantePorIdActividad(idSolicitudAyudantia);
                solicitud.setListaSolicitudserayudante(listaSolicitudserayudante);
                for (Solicitudserayudante solicitudserayudante : listaSolicitudserayudante) {
                    solicitudserayudante.setSolicitudayudantia(solicitud);
                    leerSolicitudserayudanteNivel2(solicitudserayudante);
                }

            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitud;
        }

        public Vector<Solicitudayudantia> leerSolicitudayudantiaDisponibles() throws SQLException {
            Connection con = null;
            Vector<Solicitudayudantia> listaSolicitud = new Vector<Solicitudayudantia>();
            try {
                con = conexionDB.openConexion();
                consultasSolicitudayudantia.setConexion(con);
                consultasConfiguracion.setConexion(con);
                consultasMateria.setConexion(con);
                consultasProfesor.setConexion(con);
                consultasPersona.setConexion(con);
                consultasParametro.setConexion(con);
                listaSolicitud = consultasSolicitudayudantia.leerSolicitudayudantiaDisponibles();
                for (Solicitudayudantia solicitudayudantia : listaSolicitud) {
                    leerSolicitudayudantiaNivel2(solicitudayudantia);
                }

            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return listaSolicitud;

        }

        public Solicitudayudantia existeSolicitudayudantiaPorIdAyudantia(int idAyudantiaVaria, int idMateria) throws SQLException {
            Connection con = null;
            Solicitudayudantia solicitudAyudantia = null;
            try {
                con = conexionDB.openConexion();
                consultasSolicitudayudantia.setConexion(con);

                solicitudAyudantia = consultasSolicitudayudantia.leerSolicitudayudantiaPorIdAyudantia(idAyudantiaVaria, 1, idMateria);
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitudAyudantia;
        }
        // </editor-fold >
        // <editor-fold defaultstate="collapsed" desc="Metodos de consultas SolicitudserAyudante">

        public Solicitudserayudante nuevoSolicitudserayudante(Solicitudserayudante solicitudserayudante) throws SQLException, Exception {
            Connection con = null;
            Solicitudserayudante nuevaSolicitudserayudante = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudserayudante.setConexion(con);
                nuevaSolicitudserayudante = consultasSolicitudserayudante.HLnuevoSolicitudserayudante(solicitudserayudante);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return nuevaSolicitudserayudante;

        }

        public Solicitudserayudante clonarSolicitudserayudante(Solicitudserayudante solicitudserayudante) throws Exception {
            Connection con = null;
            Solicitudserayudante cloneSolicitudserayudante = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudserayudante.setConexion(con);
                int fkParent = solicitudserayudante.getFkParent();
                solicitudserayudante.setFkParent(solicitudserayudante.getIdSolicitudSerAyudante());
                cloneSolicitudserayudante = consultasSolicitudserayudante.HLnuevoSolicitudserayudante(solicitudserayudante);
                solicitudserayudante.setFkParent(fkParent);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return cloneSolicitudserayudante;
        }

        public void guardarSolicitudserayudante(Solicitudserayudante solicitudserayudante) throws SQLException, Exception {
            Connection con = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudserayudante.setConexion(con);
                consultasSolicitudserayudante.HLmodificarSolicitudserayudante(solicitudserayudante);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }

        public Solicitudserayudante guardarYClonarSolicitudserayudante(Solicitudserayudante solicitudserayudante) throws SQLException, Exception {
            Connection con = null;
            Solicitudserayudante cloneSolicitudserayudante = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudserayudante.setConexion(con);
                consultasSolicitudserayudante.HLmodificarSolicitudserayudante(solicitudserayudante);
                int fkParent = solicitudserayudante.getFkParent();
                solicitudserayudante.setFkParent(solicitudserayudante.getIdSolicitudSerAyudante());
                cloneSolicitudserayudante = consultasSolicitudserayudante.HLnuevoSolicitudserayudante(solicitudserayudante);
                solicitudserayudante.setFkParent(fkParent);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return cloneSolicitudserayudante;
        }

        public Solicitudserayudante leerSolicitudserayudante(int idSolicitudSerAyudante) throws SQLException {
            Connection con = null;
            Solicitudserayudante solicitud = null;
            try {
                con = conexionDB.openConexion();
                consultasSolicitudserayudante.setConexion(con);
                solicitud = consultasSolicitudserayudante.leerSolicitudserayudante(idSolicitudSerAyudante);
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitud;
        }

        public Solicitudserayudante leerSolicitudserayudanteNivel2(int idSolicitudSerAyudante) throws SQLException {
            Connection con = null;
            Solicitudserayudante solicitud = null;
            Solicitudayudantia solicitudAyudantia = null;
            try {
                con = conexionDB.openConexion();

                consultasSolicitudserayudante.setConexion(con);
                solicitud = consultasSolicitudserayudante.leerSolicitudserayudante(idSolicitudSerAyudante);
                solicitudAyudantia = leerSolicitudayudantiaNivel2(solicitud.getFkIdSolicitudAyudantia());
                solicitud.setSolicitudayudantia(solicitudAyudantia);
                solicitud = leerSolicitudserayudanteNivel2(solicitud);


            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitud;

        }

        public Solicitudserayudante leerSolicitudserayudanteNivel2(Solicitudserayudante solicitudserayudante) throws SQLException {
            Estudiante estudiante;
            Persona personaEstudiante;
            Connection con = null;
            Parametro carrera;
            try {
                con = conexionDB.openConexion();
                consultasEstudiante.setConexion(con);
                consultasPersona.setConexion(con);
                consultasParametro.setConexion(con);
                consultasDatosacademicos.setConexion(con);
                consultasDatosfinancieros.setConexion(con);
                consultasMateria.setConexion(con);
                consultasDatosmateria.setConexion(con);
                if (solicitudserayudante.getFkIdEstudiante() != 0) {
                    estudiante = consultasEstudiante.leerEstudiante(solicitudserayudante.getFkIdEstudiante());

                    personaEstudiante = consultasPersona.leerPersona(estudiante.getIdEstudiante());
                    estudiante.setPersona(personaEstudiante);
                    solicitudserayudante.setEstudiante(estudiante);
                }
                String temp;
                if (solicitudserayudante.getFkIdCarrera() != 0) {
                    carrera = consultasParametro.leerParametro(solicitudserayudante.getFkIdCarrera());
                    if (carrera.getFkIdParent() != 0) {
                        temp = consultasParametro.leerParametro(carrera.getFkIdParent()).getNombre();
                        temp += " especialización " + carrera.getNombre();
                        carrera.setNombre(temp);
                    }
                    solicitudserayudante.setCarrera(carrera);
                }
                Datosacademicos datoAcademico;
                if (solicitudserayudante.getFkIdDatoAcademico() != 0) {
                    datoAcademico = consultasDatosacademicos.leerDatosacademicos(solicitudserayudante.getFkIdDatoAcademico());
                    solicitudserayudante.setDatosacademicos(datoAcademico);
                }
                Datosfinancieros datosFinancieros;
                if (solicitudserayudante.getFkIdDatosFinancieros() != 0) {
                    datosFinancieros = consultasDatosfinancieros.leerDatosfinancieros(solicitudserayudante.getFkIdDatosFinancieros());
                    solicitudserayudante.setDatosfinancieros(datosFinancieros);
                }
                Datosmateria datosmateria;
                if ((solicitudserayudante.getFkIdEstudiante() != 0) && solicitudserayudante.getSolicitudayudantia().getFkIdMateria() != 0) {
                    datosmateria = consultasDatosmateria.leerDatosmateria(solicitudserayudante.getFkIdEstudiante(), solicitudserayudante.getSolicitudayudantia().getFkIdMateria());
                    solicitudserayudante.setDatosmateria(datosmateria);
                }
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitudserayudante;
        }

        public boolean aplicoASolicitudAyudantia(String usuario, String nombreInstanciaProcesoProf) throws SQLException {
            Connection con = null;
            Solicitudserayudante solicitud = null;
            try {
                con = conexionDB.openConexion();
                consultasSolicitudserayudante.setConexion(con);
                consultasPersona.setConexion(con);
                consultasEstudiante.setConexion(con);
                solicitud = consultasSolicitudserayudante.leerSolicitudserayudantePorUsuarioPornombreInstancia(-1, usuario, nombreInstanciaProcesoProf);
                if (solicitud != null) {
                    return true;
                }

            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return false;
        }
        // </editor-fold>
    }

    public class LogBusquedaSolicitud {

        public Vector<Rg_Solicitud> buscarSolicitudAyudantia(java.sql.Date fechaCreacion_desde, java.sql.Date fechaCreacion_hasta,
                java.sql.Date fechaModificacion_desde, java.sql.Date fechaModificacion_hasta,
                String estado,
                String solicitante, String participante,
                String titulo) throws SQLException {

            Connection con = null;
            Vector<Solicitudayudantia> listaSolicitudAyudantia;
            Vector<Rg_Solicitud> listaRg_Solicitud = new Vector<Rg_Solicitud>();
            Rg_Solicitud rg_Solicitud;

            try {
                con = conexionDB.openConexion();
                busquedaSolicitud.setConexion(con);
                consultasConfiguracion.setConexion(con);
                consultasMateria.setConexion(con);
                consultasProfesor.setConexion(con);
                consultasPersona.setConexion(con);
                listaSolicitudAyudantia = busquedaSolicitud.buscarSolicitudAyudantia(fechaCreacion_desde, fechaCreacion_hasta, fechaModificacion_desde, fechaModificacion_hasta, estado, solicitante, participante, titulo);
                for (Solicitudayudantia solicitud : listaSolicitudAyudantia) {
                    solicitud = getLogAyudantia().leerSolicitudayudantiaNivel2(solicitud);

                    rg_Solicitud = solicitud;
                    rg_Solicitud.setSolicitante(solicitud.getProfesor().getPersona().toString());
                    rg_Solicitud.setModelo(Constantes.TipoSolicitud.Ayudantia.toString() + "_" + solicitud.getIdSolicitudAyudantia());
                    //Se va a utilizar el campo descripcion para almacenar los Participantes de la solicitud
                    rg_Solicitud.setDescripcion(solicitud.getDecano().getPersona().toString() + "(Decano)");
                    listaRg_Solicitud.add(rg_Solicitud);
                }
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return listaRg_Solicitud;

        }

        public Vector<Rg_Solicitud> buscarSolicitudSerAyudante(java.sql.Date fechaCreacion_desde, java.sql.Date fechaCreacion_hasta,
                java.sql.Date fechaModificacion_desde, java.sql.Date fechaModificacion_hasta,
                String estado,
                String solicitante, String participante,
                String titulo) throws SQLException {

            Connection con = null;
            Vector<Rg_Solicitud> listaRg_Solicitud = new Vector<Rg_Solicitud>();
            Vector<Solicitudserayudante> listaSolicitudSerAyudante;
            Rg_Solicitud rg_Solicitud;
            Solicitudayudantia solicitudAyudantia;

            try {
                con = conexionDB.openConexion();
                busquedaSolicitud.setConexion(con);
                listaSolicitudSerAyudante = busquedaSolicitud.buscarSolicitudSerAyudante(fechaCreacion_desde, fechaCreacion_hasta, fechaModificacion_desde, fechaModificacion_hasta, estado, solicitante, participante, titulo);
                for (Solicitudserayudante solicitud : listaSolicitudSerAyudante) {
                    solicitudAyudantia = getLogAyudantia().leerSolicitudayudantiaNivel2(solicitud.getFkIdSolicitudAyudantia());
                    solicitud.setSolicitudayudantia(solicitudAyudantia);
                    solicitud = getLogAyudantia().leerSolicitudserayudanteNivel2(solicitud);

                    rg_Solicitud = solicitud;
                    rg_Solicitud.setSolicitante(solicitud.getEstudiante().toString());
                    rg_Solicitud.setModelo(Constantes.TipoSolicitud.SerAyudante.toString() + "_" + solicitud.getIdSolicitudSerAyudante());
                    //Se va a utilizar el campo descripcion para almacenar los Participantes de la solicitud
                    rg_Solicitud.setDescripcion(solicitudAyudantia.getDecano().getPersona().toString() + "(Decano), " + solicitudAyudantia.getProfesor().getPersona().toString() + "(Profesor)");
                    listaRg_Solicitud.add(rg_Solicitud);
                }
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return listaRg_Solicitud;

        }

        public Vector<Rg_Solicitud> buscarSolicitudCambioCarrera(java.sql.Date fechaCreacion_desde, java.sql.Date fechaCreacion_hasta,
                java.sql.Date fechaModificacion_desde, java.sql.Date fechaModificacion_hasta,
                String estado,
                String solicitante, String participante,
                String titulo) throws SQLException {

            Connection con = null;
            Vector<Rg_Solicitud> listaRg_Solicitud = new Vector<Rg_Solicitud>();
            Vector<Solicitudcambiocarrera> listaSolicitudCambioCarrera;
            Rg_Solicitud rg_Solicitud;

            try {
                con = conexionDB.openConexion();
                busquedaSolicitud.setConexion(con);
                consultasParametro.setConexion(con);
                consultasEstudiante.setConexion(con);
                consultasPersona.setConexion(con);
                consultasProfesor.setConexion(con);
                listaSolicitudCambioCarrera = busquedaSolicitud.buscarSolicitudCambioCarrera(fechaCreacion_desde, fechaCreacion_hasta, fechaModificacion_desde, fechaModificacion_hasta, estado, solicitante, participante, titulo);
                for (Solicitudcambiocarrera solicitud : listaSolicitudCambioCarrera) {
                    solicitud = getLogCambioCarrera().leerSolicitudCambioNivel2(solicitud);

                    rg_Solicitud = solicitud;
                    rg_Solicitud.setSolicitante(solicitud.getEstudiante().getPersona().toString());
                    rg_Solicitud.setModelo(Constantes.TipoSolicitud.CambioCarrera.toString() + "_" + solicitud.getIdSolicitudCambioCarrera());
                    //Se va a utilizar el campo descripcion para almacenar los Participantes de la solicitud
                    rg_Solicitud.setDescripcion(solicitud.getSubDecano().getPersona().toString() + "(Subdecano), " + solicitud.getProfesor().getPersona().toString() + "(Profesor)");
                    listaRg_Solicitud.add(rg_Solicitud);
                }
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return listaRg_Solicitud;

        }

        public Vector<Rg_Solicitud> buscarSolicitudConvalidacion(java.sql.Date fechaCreacion_desde, java.sql.Date fechaCreacion_hasta,
                java.sql.Date fechaModificacion_desde, java.sql.Date fechaModificacion_hasta,
                String estado,
                String solicitante, String participante,
                String titulo) throws SQLException {

            Connection con = null;
            Vector<Rg_Solicitud> listaRg_Solicitud = new Vector<Rg_Solicitud>();
            Vector<Solicitudconvalidacionmateria> listaSolicitudConvalidacion;
            Rg_Solicitud rg_Solicitud;

            try {
                con = conexionDB.openConexion();
                busquedaSolicitud.setConexion(con);
                consultasMateria.setConexion(con);
                consultasEstudiante.setConexion(con);
                consultasPersona.setConexion(con);
                consultasProfesor.setConexion(con);
                listaSolicitudConvalidacion = busquedaSolicitud.buscarSolicitudConvalidacion(fechaCreacion_desde, fechaCreacion_hasta, fechaModificacion_desde, fechaModificacion_hasta, estado, solicitante, participante, titulo);
                for (Solicitudconvalidacionmateria solicitud : listaSolicitudConvalidacion) {
                    solicitud = getLogConvalidacionMateria().leerSolicitudConvalidacionNivel2(solicitud);

                    rg_Solicitud = solicitud;
                    rg_Solicitud.setSolicitante(solicitud.getEstudiante().getPersona().toString());
                    rg_Solicitud.setModelo(Constantes.TipoSolicitud.ConvalidacionMateria.toString() + "_" + solicitud.getIdSolicitudConvalidacion());
                    //Se va a utilizar el campo descripcion para almacenar los Participantes de la solicitud
                    String participantes = null;
                    if (solicitud.getSubDecano() != null) {
                        participantes = solicitud.getSubDecano().toString() + "(Subdecano)";
                    }
                    if (solicitud.getProfesor() != null) {
                        if (participantes == null) {
                            participantes = solicitud.getProfesor().toString() + "(Profesor)";
                        } else {
                            participantes = participantes + ", " + solicitud.getProfesor().toString() + "(Profesor)";
                        }
                    }

                    rg_Solicitud.setDescripcion(participantes);
                    listaRg_Solicitud.add(rg_Solicitud);
                }
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return listaRg_Solicitud;

        }

        public Vector<Rg_Solicitud> buscarSolicitudAperturaPostgrado(java.sql.Date fechaCreacion_desde, java.sql.Date fechaCreacion_hasta,
                java.sql.Date fechaModificacion_desde, java.sql.Date fechaModificacion_hasta,
                String estado,
                String solicitante, String participante,
                String titulo) throws SQLException {

            Connection con = null;
            Vector<Rg_Solicitud> listaRg_Solicitud = new Vector<Rg_Solicitud>();
            Vector<Solicitudaperturapostgrado> listaSolicitudAperturaPostgrado;

            try {
                con = conexionDB.openConexion();
                busquedaSolicitud.setConexion(con);
                consultasProfesor.setConexion(con);
                consultasPersona.setConexion(con);

                Rg_Solicitud rg_Solicitud;
                listaSolicitudAperturaPostgrado = busquedaSolicitud.buscarSolicitudAperturaPostgrado(fechaCreacion_desde, fechaCreacion_hasta, fechaModificacion_desde, fechaModificacion_hasta, estado, solicitante, participante, titulo);
                System.out.println("listaSolicitudAperturaPostgrado");
                for (Solicitudaperturapostgrado solicitud : listaSolicitudAperturaPostgrado) {
                    System.out.println("solicitud: " + solicitud);
                    solicitud = getLogAperturaPostgrado().leerSolicitudAperturaNivel2(solicitud);

                    rg_Solicitud = solicitud;
                    rg_Solicitud.setSolicitante(solicitud.getProfesor().getPersona().toString());
                    rg_Solicitud.setModelo(Constantes.TipoSolicitud.AperturaPostgrado.toString() + "_" + solicitud.getIdSolicitudApertura());
                    //Se va a utilizar el campo descripcion para almacenar los Participantes de la solicitud
                    String participantes = null;
                    participantes = solicitud.getDecano().getPersona().toString() + "(Decano)";
                    if (solicitud.getEvaluador1() != null) {
                        participantes = participantes + ", " + solicitud.getEvaluador1().getPersona().toString() + "(Evaluador)";
                    }
                    if (solicitud.getEvaluador2() != null) {
                        participantes = participantes + ", " + solicitud.getEvaluador2().getPersona().toString() + "(Evaluador)";
                    }
                    if (solicitud.getEvaluador3() != null) {
                        participantes = participantes + ", " + solicitud.getEvaluador3().getPersona().toString() + "(Evaluador)";
                    }
                    rg_Solicitud.setDescripcion(participantes);
                    listaRg_Solicitud.add(rg_Solicitud);
                }
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return listaRg_Solicitud;

        }
    }
// <editor-fold defaultstate="collapsed" desc="Metodos anteriores"> 
//     public String getNombreAyudantia(String nombreInstanciaProf, UserSession usrSession,ProjectSession prjSession) {
//        String nombreActividad = "Solicitar ayudantes";
//        BnNodeValue actividad;
//        BnNodePropertyValue property;
//        if (usrSession != null && prjSession != null) {
//            if (nombreInstanciaProf != null) {
//                try {
//                    prjSession.initProject(nombreInstanciaProf);
//                    actividad = usrSession.getNode(nombreInstanciaProf, nombreActividad);
//
//                    if (actividad != null) {
//                        property = prjSession.getNodeProperty(nombreActividad, "formulario");
//                        EnProfesorSolicitaAyudantes enProfesorSolicitaAyudantes = new EnProfesorSolicitaAyudantes();
//                        enProfesorSolicitaAyudantes.cargarXML(property.getTheValue());
//                        int tipoAyudantia = Integer.parseInt(enProfesorSolicitaAyudantes.getTipoAyudantia());
//                        int idAyudantia = Integer.parseInt(enProfesorSolicitaAyudantes.getNombreAyudantia());
//                        String nombre = leerAyudantia(tipoAyudantia, idAyudantia).getNombre();
//                        return nombre;
//                    }
//                } catch (SAXException ex) {
//                    Logger.getLogger(CTRL_ConfirmacionEstudiante.class.getName()).log(Level.SEVERE, null, ex);
//                } catch (IOException ex) {
//                    Logger.getLogger(CTRL_ConfirmacionEstudiante.class.getName()).log(Level.SEVERE, null, ex);
//                } catch (ParserConfigurationException ex) {
//                    Logger.getLogger(CTRL_ConfirmacionEstudiante.class.getName()).log(Level.SEVERE, null, ex);
//                } catch (HeroException ex) {
//                    Logger.getLogger(CTRL_ConfirmacionEstudiante.class.getName()).log(Level.SEVERE, null, ex);
//                }
//            }
//        }
//        return null;
//    }
//  public String getTipoAyudantia(String nombreInstanciaProf, UserSession usrSession,ProjectSession prjSession) {
//        String nombreActividad = "Solicitar ayudantes";
//        BnNodeValue actividad;
//        BnNodePropertyValue property;
//        if (usrSession != null && prjSession != null) {
//            if (nombreInstanciaProf != null) {
//                try {
//                    prjSession.initProject(nombreInstanciaProf);
//                    actividad = usrSession.getNode(nombreInstanciaProf, nombreActividad);
//
//                    if (actividad != null) {
//                        property = prjSession.getNodeProperty(nombreActividad, "formulario");
//                        EnProfesorSolicitaAyudantes enProfesorSolicitaAyudantes = new EnProfesorSolicitaAyudantes();
//                        enProfesorSolicitaAyudantes.cargarXML(property.getTheValue());
//                        int tipoAyudantia = Integer.parseInt(enProfesorSolicitaAyudantes.getTipoAyudantia());
//                        int idAyudantia = Integer.parseInt(enProfesorSolicitaAyudantes.getNombreAyudantia());
//                        String tipo = leerTipoAyudantia(tipoAyudantia);
//                       return tipo;
//                    }
//                } catch (SAXException ex) {
//                    Logger.getLogger(CTRL_ConfirmacionEstudiante.class.getName()).log(Level.SEVERE, null, ex);
//                } catch (IOException ex) {
//                    Logger.getLogger(CTRL_ConfirmacionEstudiante.class.getName()).log(Level.SEVERE, null, ex);
//                } catch (ParserConfigurationException ex) {
//                    Logger.getLogger(CTRL_ConfirmacionEstudiante.class.getName()).log(Level.SEVERE, null, ex);
//                } catch (HeroException ex) {
//                    Logger.getLogger(CTRL_ConfirmacionEstudiante.class.getName()).log(Level.SEVERE, null, ex);
//                }
//            }
//        }return null;
//    }
// </editor-fold >    

    public void addCookieMensaje(String mensaje, ExternalContext externalContext) {
        Cookie cookieMensaje;
        cookieMensaje = new Cookie("mensaje", mensaje);
        cookieMensaje.setMaxAge(-1);
        cookieMensaje.setPath("/WA_SolicitudesFIEC/faces/general/");
        HttpServletResponse response = (HttpServletResponse) externalContext.getResponse();
        response.addCookie(cookieMensaje);
    }
}
